diff --git a/stage0/src/Init/Control/Option.lean b/stage0/src/Init/Control/Option.lean
index f78636d030..7cde967b1c 100644
--- a/stage0/src/Init/Control/Option.lean
+++ b/stage0/src/Init/Control/Option.lean
@@ -21,47 +21,51 @@ def OptionT (m : Type u → Type v) (α : Type u) : Type v :=
 namespace OptionT
 variable {m : Type u → Type v} [Monad m] {α β : Type u}
 
-@[inline] protected def bind (x : OptionT m α) (f : α → OptionT m β) : OptionT m β := id (α := m (Option β)) do
+protected def mk (x : m (Option α)) : OptionT m α :=
+  x
+
+@[inline] protected def bind (x : OptionT m α) (f : α → OptionT m β) : OptionT m β := OptionT.mk do
   match (← x) with
   | some a => f a
   | none   => pure none
 
-@[inline] protected def pure (a : α) : OptionT m α := id (α := m (Option α)) do
+@[inline] protected def pure (a : α) : OptionT m α := OptionT.mk do
   pure (some a)
 
-instance : Monad (OptionT m) := {
+instance : Monad (OptionT m) where
   pure := OptionT.pure
   bind := OptionT.bind
-}
 
-@[inline] protected def orElse (x : OptionT m α) (y : OptionT m α) : OptionT m α := id (α := m (Option α)) do
+@[inline] protected def orElse (x : OptionT m α) (y : OptionT m α) : OptionT m α := OptionT.mk do
   match (← x) with
   | some a => pure (some a)
   | _      => y
 
-@[inline] protected def fail : OptionT m α := id (α := m (Option α)) do
+@[inline] protected def fail : OptionT m α := OptionT.mk do
   pure none
 
-instance : Alternative (OptionT m) := {
+instance : Alternative (OptionT m) where
   failure := OptionT.fail
   orElse  := OptionT.orElse
-}
 
-@[inline] protected def lift (x : m α) : OptionT m α := id (α := m (Option α)) do
+@[inline] protected def lift (x : m α) : OptionT m α := OptionT.mk do
   return some (← x)
 
 instance : MonadLift m (OptionT m) := ⟨OptionT.lift⟩
 
 instance : MonadFunctor m (OptionT m) := ⟨fun f x => f x⟩
 
-@[inline] protected def tryCatch (x : OptionT m α) (handle : Unit → OptionT m α) : OptionT m α := id (α := m (Option α)) do
+@[inline] protected def tryCatch (x : OptionT m α) (handle : Unit → OptionT m α) : OptionT m α := OptionT.mk do
   let some a ← x | handle ()
   pure a
 
-instance : MonadExceptOf Unit (OptionT m) := {
+instance : MonadExceptOf Unit (OptionT m) where
   throw    := fun _ => OptionT.fail
   tryCatch := OptionT.tryCatch
-}
+
+instance (ε : Type u) [Monad m] [MonadExceptOf ε m] : MonadExceptOf ε (OptionT m) where
+  throw e           := OptionT.mk <| throwThe ε e
+  tryCatch x handle := OptionT.mk <| tryCatchThe ε x handle
 
 end OptionT
 
diff --git a/stage0/src/Init/Core.lean b/stage0/src/Init/Core.lean
index bf0495da2c..976cd26cd5 100644
--- a/stage0/src/Init/Core.lean
+++ b/stage0/src/Init/Core.lean
@@ -114,6 +114,7 @@ notation "∅"     => EmptyCollection.emptyCollection
 /- Remark: tasks have an efficient implementation in the runtime. -/
 structure Task (α : Type u) : Type u where
   pure :: (get : α)
+  deriving Inhabited
 
 attribute [extern "lean_task_pure"] Task.pure
 attribute [extern "lean_task_get_own"] Task.get
diff --git a/stage0/src/Init/Data/Int/Basic.lean b/stage0/src/Init/Data/Int/Basic.lean
index a40b134884..f09be2bf6e 100644
--- a/stage0/src/Init/Data/Int/Basic.lean
+++ b/stage0/src/Init/Data/Int/Basic.lean
@@ -160,7 +160,7 @@ def toNat : Int → Nat
 
 def natMod (m n : Int) : Nat := (m % n).toNat
 
-protected def Int.pow (m : Int) : Nat → Int
+protected def pow (m : Int) : Nat → Int
   | 0      => 1
   | succ n => Int.pow m n * m
 
diff --git a/stage0/src/Init/Data/List/Basic.lean b/stage0/src/Init/Data/List/Basic.lean
index f3a78bb221..c04cb9f729 100644
--- a/stage0/src/Init/Data/List/Basic.lean
+++ b/stage0/src/Init/Data/List/Basic.lean
@@ -357,4 +357,12 @@ def dropLast {α} : List α → List α
     simp[dropLast, ih]
     rfl
 
+def maximum? [LT α] [DecidableRel (@LT.lt α _)] : List α → Option α
+  | []    => none
+  | a::as => some <| as.foldl max a
+
+def minimum? [LE α] [DecidableRel (@LE.le α _)] : List α → Option α
+  | []    => none
+  | a::as => some <| as.foldl min a
+
 end List
diff --git a/stage0/src/Init/Data/Ord.lean b/stage0/src/Init/Data/Ord.lean
index 36bbbf1f39..e5e5f4ea30 100644
--- a/stage0/src/Init/Data/Ord.lean
+++ b/stage0/src/Init/Data/Ord.lean
@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2021 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Author: Dany Fabian
+Authors: Dany Fabian, Sebastian Ullrich
 -/
 
 prelude
@@ -41,10 +41,38 @@ instance : Ord String where
 instance (n : Nat) : Ord (Fin n) where
   compare x y := compare x.val y.val
 
-def USize.cmp (a b : USize) : Ordering := compare a.val b.val
+instance : Ord UInt8 where
+  compare x y := compareOfLessAndEq x y
+
+instance : Ord UInt16 where
+  compare x y := compareOfLessAndEq x y
+
+instance : Ord UInt32 where
+  compare x y := compareOfLessAndEq x y
+
+instance : Ord UInt64 where
+  compare x y := compareOfLessAndEq x y
 
 instance : Ord USize where
   compare x y := compareOfLessAndEq x y
 
 instance : Ord Char where
   compare x y := compareOfLessAndEq x y
+
+
+def ltOfOrd [Ord α] : LT α where
+  lt a b := compare a b == Ordering.lt
+
+instance [Ord α] : DecidableRel (@LT.lt α ltOfOrd) :=
+  inferInstanceAs (DecidableRel (fun a b => compare a b == Ordering.lt))
+
+def Ordering.isLE : Ordering → Bool
+  | Ordering.lt => true
+  | Ordering.eq => true
+  | Ordering.gt => false
+
+def leOfOrd [Ord α] : LE α where
+  le a b := (compare a b).isLE
+
+instance [Ord α] : DecidableRel (@LE.le α leOfOrd) :=
+  inferInstanceAs (DecidableRel (fun a b => (compare a b).isLE))
diff --git a/stage0/src/Init/Data/String/Basic.lean b/stage0/src/Init/Data/String/Basic.lean
index 16a28bc643..71bbce7ae2 100644
--- a/stage0/src/Init/Data/String/Basic.lean
+++ b/stage0/src/Init/Data/String/Basic.lean
@@ -109,6 +109,23 @@ def revPosOf (s : String) (c : Char) : Option Pos :=
   if s.bsize == 0 then none
   else revPosOfAux s c (s.prev s.bsize)
 
+partial def findAux (s : String) (p : Char → Bool) (stopPos : Pos) (pos : Pos) : Pos :=
+  if pos == stopPos then pos
+  else if p (s.get pos) then pos
+       else findAux s p stopPos (s.next pos)
+
+@[inline] def find (s : String) (p : Char → Bool) : Pos :=
+  findAux s p s.bsize 0
+
+partial def revFindAux (s : String) (p : Char → Bool) (pos : Pos) : Option Pos :=
+ if p (s.get pos) then some pos
+ else if pos == 0 then none
+ else revFindAux s p (s.prev pos)
+
+def revFind (s : String) (p : Char → Bool) : Option Pos :=
+  if s.bsize == 0 then none
+  else revFindAux s p (s.prev s.bsize)
+
 private def utf8ExtractAux₂ : List Char → Pos → Pos → List Char
   | [],    _, _ => []
   | c::cs, i, e => if i = e then [] else c :: utf8ExtractAux₂ cs (i + csize c) e
@@ -471,7 +488,8 @@ def toNat? (s : Substring) : Option Nat :=
     none
 
 def beq (ss1 ss2 : Substring) : Bool :=
-  ss1.toString == ss2.toString
+  -- TODO: should not allocate
+  ss1.bsize == ss2.bsize && ss1.toString == ss2.toString
 
 instance hasBeq : BEq Substring := ⟨beq⟩
 
@@ -503,6 +521,12 @@ def takeRightWhile (s : String) (p : Char → Bool) : String :=
 def dropRightWhile (s : String) (p : Char → Bool) : String :=
   (s.toSubstring.dropRightWhile p).toString
 
+def startsWith (s pre : String) : Bool :=
+  s.toSubstring.take pre.length == pre.toSubstring
+
+def endsWith (s post : String) : Bool :=
+  s.toSubstring.takeRight post.length == post.toSubstring
+
 def trimRight (s : String) : String :=
   s.toSubstring.trimRight.toString
 
diff --git a/stage0/src/Init/Prelude.lean b/stage0/src/Init/Prelude.lean
index d0e20b4561..38f11bae37 100644
--- a/stage0/src/Init/Prelude.lean
+++ b/stage0/src/Init/Prelude.lean
@@ -360,6 +360,12 @@ class LT (α : Type u) where lt : α → α → Prop
 @[reducible] def GE.ge {α : Type u} [LE α] (a b : α) : Prop := LE.le b a
 @[reducible] def GT.gt {α : Type u} [LT α] (a b : α) : Prop := LT.lt b a
 
+@[inline] def max [LT α] [DecidableRel (@LT.lt α _)] (a b : α) : α :=
+  ite (LT.lt b a) a b
+
+@[inline] def min [LE α] [DecidableRel (@LE.le α _)] (a b : α) : α :=
+  ite (LE.le a b) a b
+
 class HAdd (α : Type u) (β : Type v) (γ : outParam (Type w)) where
   hAdd : α → β → γ
 
@@ -1586,6 +1592,9 @@ class Hashable (α : Sort u) where
 
 export Hashable (hash)
 
+@[extern "lean_usize_mix_hash"]
+constant mixUSizeHash (u₁ u₂ : USize) : USize
+
 @[extern "lean_usize_mix_hash"]
 constant mixHash (u₁ u₂ : USize) : USize
 
diff --git a/stage0/src/Init/System/FilePath.lean b/stage0/src/Init/System/FilePath.lean
index 59e66a974b..343506e199 100644
--- a/stage0/src/Init/System/FilePath.lean
+++ b/stage0/src/Init/System/FilePath.lean
@@ -1,16 +1,29 @@
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Leonardo de Moura
+Authors: Leonardo de Moura, Sebastian Ullrich
 -/
 prelude
 import Init.System.Platform
 import Init.Data.String.Basic
+import Init.Data.Repr
+import Init.Data.ToString.Basic
 
 namespace System
-namespace FilePath
 open Platform
 
+structure FilePath where
+  toString : String
+  deriving Inhabited, DecidableEq
+
+instance : Repr FilePath where
+  reprPrec p := Repr.addAppParen ("FilePath.mk " ++ repr p.toString)
+
+instance : ToString FilePath where
+  toString p := p.toString
+
+namespace FilePath
+
 /-- The character that separates directories. In the case where more than one character is possible, `pathSeparator` is the 'ideal' one. -/
 def pathSeparator : Char :=
   if isWindows then '\\' else '/'
@@ -19,36 +32,105 @@ def pathSeparator : Char :=
 def pathSeparators : List Char :=
   if isWindows then ['\\', '/'] else ['/']
 
-/-- The character that is used to separate the entries in the $PATH (or %PATH%) environment variable. -/
-def searchPathSeparator : Char :=
-  if isWindows then ';' else ':'
-
-def splitSearchPath (s : String) : List String :=
-  s.split (fun c => searchPathSeparator == c)
-
 /-- File extension character -/
 def extSeparator : Char := '.'
 
-def exeSuffix : String :=
-if isWindows then ".exe" else ""
+def exeExtension : String :=
+  if isWindows then "exe" else ""
 
 /-- Case-insensitive file system -/
 def isCaseInsensitive : Bool := isWindows || isOSX
 
-def normalizePath (fname : String) : String :=
-  if pathSeparators.length == 1 && !isCaseInsensitive then fname
-  else fname.map fun c =>
-    if pathSeparators.any (fun c' => c == c') then pathSeparator
-    -- else if isCaseInsensitive then c.toLower
-    else c
+-- TODO: normalize `a/`, `a//b`, etc.
+def normalize (p : FilePath) (normalizeCase := isCaseInsensitive) : FilePath :=
+  if pathSeparators.length == 1 && !normalizeCase then p
+  else ⟨p.toString.map fun c =>
+    if pathSeparators.contains c then pathSeparator
+    else if normalizeCase then c.toLower
+    else c⟩
 
-def parent (fname : String) : Option String :=
-  let fname := normalizePath fname
-  fname.extract 0 <$> fname.revPosOf pathSeparator
+-- the following functions follow the names and semantics from Rust's `std::path::Path`
+
+def isAbsolute (p : FilePath) : Bool :=
+  pathSeparators.contains p.toString.front || (isWindows && p.toString.bsize >= 1 && p.toString[1] == ':')
+
+def isRelative (p : FilePath) : Bool :=
+  !p.isAbsolute
+
+def join (p sub : FilePath) : FilePath :=
+  if sub.isAbsolute then
+    sub
+  else
+    ⟨p.toString ++ pathSeparator.toString ++ sub.toString⟩
+
+instance : Div FilePath where
+  div := FilePath.join
+
+instance : HDiv FilePath String FilePath where
+  hDiv p sub := FilePath.join p ⟨sub⟩
+
+private def posOfLastSep (p : FilePath) : Option String.Pos :=
+  p.toString.revFind pathSeparators.contains
+
+def parent (p : FilePath) : Option FilePath :=
+  FilePath.mk <$> p.toString.extract 0 <$> posOfLastSep p
+
+def fileName (p : FilePath) : Option String :=
+  let lastPart := match posOfLastSep p with
+    | some sepPos => p.toString.extract (sepPos + 1) p.toString.bsize
+    | none        => p.toString
+  if lastPart.isEmpty || lastPart == "." || lastPart == ".." then none else some lastPart
+
+/-- Extracts the stem (non-extension) part of `p.fileName`. -/
+def fileStem (p : FilePath) : Option String :=
+  p.fileName.map fun fname =>
+    match fname.revPosOf '.' with
+    | some 0   => fname
+    | some pos => fname.extract 0 pos
+    | none     => fname
+
+def extension (p : FilePath) : Option String :=
+  p.fileName.bind fun fname =>
+    match fname.revPosOf '.' with
+    | some 0   => none
+    | some pos => fname.extract (pos + 1) fname.bsize
+    | none     => none
+
+def withFileName (p : FilePath) (fname : String) : FilePath :=
+  match p.parent with
+  | none => ⟨fname⟩
+  | some p => p / fname
+
+def withExtension (p : FilePath) (ext : String) : FilePath :=
+  match p.fileStem with
+  | none => p
+  | some stem => p.withFileName (if ext.isEmpty then stem else stem ++ "." ++ ext)
+
+def components (p : FilePath) : List String :=
+  p.normalize (normalizeCase := false) |>.toString.splitOn pathSeparator.toString
 
 end FilePath
 
-def mkFilePath (parts : List String) : String :=
-  String.intercalate FilePath.pathSeparator.toString parts
+def mkFilePath (parts : List String) : FilePath :=
+  ⟨String.intercalate FilePath.pathSeparator.toString parts⟩
+
+instance : Coe String FilePath where
+  coe := FilePath.mk
+
+abbrev SearchPath := List FilePath
+
+namespace SearchPath
+
+/-- The character that is used to separate the entries in the $PATH (or %PATH%) environment variable. -/
+protected def separator : Char :=
+  if isWindows then ';' else ':'
+
+def parse (s : String) : SearchPath :=
+  s.split (fun c => SearchPath.separator == c) |>.map FilePath.mk
+
+def toString (path : SearchPath) : String :=
+  SearchPath.separator.toString.intercalate (path.map FilePath.toString)
+
+end SearchPath
 
 end System
diff --git a/stage0/src/Init/System/IO.lean b/stage0/src/Init/System/IO.lean
index 18e7a7f969..d69c2f4beb 100644
--- a/stage0/src/Init/System/IO.lean
+++ b/stage0/src/Init/System/IO.lean
@@ -12,6 +12,9 @@ import Init.System.IOError
 import Init.System.FilePath
 import Init.System.ST
 import Init.Data.ToString.Macro
+import Init.Data.Ord
+
+open System
 
 /-- Like https://hackage.haskell.org/package/ghc-Prim-0.5.2.0/docs/GHC-Prim.html#t:RealWorld.
     Makes sure we never reorder `IO` operations.
@@ -108,6 +111,14 @@ constant mapTask (f : α → IO β) (t : Task α) (prio := Task.Priority.default
 @[extern "lean_io_bind_task"]
 constant bindTask (t : Task α) (f : α → IO (Task (Except IO.Error β))) (prio := Task.Priority.default) : IO (Task (Except IO.Error β))
 
+def mapTasks (f : List α → IO β) (tasks : List (Task α)) (prio := Task.Priority.default) : IO (Task (Except IO.Error β)) :=
+  go tasks []
+where
+  go
+    | t::ts, as =>
+      IO.bindTask t (fun a => go ts (a :: as)) prio
+    | [], as => IO.asTask (f as.reverse) prio
+
 /-- Check if the task's cancellation flag has been set by calling `IO.cancel` or dropping the last reference to the task. -/
 @[extern "lean_io_check_canceled"] constant checkCanceled : IO Bool
 
@@ -170,7 +181,7 @@ def fopenFlags (m : FS.Mode) (b : Bool) : String :=
   let bin := if b then "b" else "t"
   mode ++ bin
 
-@[extern "lean_io_prim_handle_mk"] constant Handle.mk (s : @& String) (mode : @& String) : IO Handle
+@[extern "lean_io_prim_handle_mk"] constant Handle.mk (fn : @& FilePath) (mode : @& String) : IO Handle
 @[extern "lean_io_prim_handle_is_eof"] constant Handle.isEof (h : @& Handle) : IO Bool
 @[extern "lean_io_prim_handle_flush"] constant Handle.flush (h : @& Handle) : IO Unit
 @[extern "lean_io_prim_handle_read"] constant Handle.read  (h : @& Handle) (bytes : USize) : IO ByteArray
@@ -180,23 +191,21 @@ def fopenFlags (m : FS.Mode) (b : Bool) : String :=
 @[extern "lean_io_prim_handle_put_str"] constant Handle.putStr (h : @& Handle) (s : @& String) : IO Unit
 
 @[extern "lean_io_getenv"] constant getEnv (var : @& String) : IO (Option String)
-@[extern "lean_io_realpath"] constant realPath (fname : String) : IO String
-@[extern "lean_io_is_dir"] constant isDir (fname : @& String) : IO Bool
-@[extern "lean_io_file_exists"] constant fileExists (fname : @& String) : IO Bool
-@[extern "lean_io_remove_file"] constant removeFile (fname : @& String) : IO Unit
-@[extern "lean_io_app_dir"] constant appPath : IO String
-@[extern "lean_io_current_dir"] constant currentDir : IO String
+@[extern "lean_io_realpath"] constant realPath (fname : FilePath) : IO FilePath
+@[extern "lean_io_remove_file"] constant removeFile (fname : @& FilePath) : IO Unit
+@[extern "lean_io_app_dir"] constant appPath : IO FilePath
+@[extern "lean_io_current_dir"] constant currentDir : IO FilePath
 
 end Prim
 
 namespace FS
 variable [Monad m] [MonadLiftT IO m]
 
-def Handle.mk (s : String) (Mode : Mode) (bin : Bool := true) : m Handle :=
-  liftM (Prim.Handle.mk s (Prim.fopenFlags Mode bin))
+def Handle.mk (fn : FilePath) (Mode : Mode) (bin : Bool := true) : m Handle :=
+  liftM (Prim.Handle.mk fn (Prim.fopenFlags Mode bin))
 
 @[inline]
-def withFile (fn : String) (mode : Mode) (f : Handle → m α) : m α :=
+def withFile (fn : FilePath) (mode : Mode) (f : Handle → m α) : m α :=
   Handle.mk fn mode >>= f
 
 /-- returns whether the end of the file has been reached while reading a file.
@@ -231,15 +240,15 @@ partial def Handle.readToEnd (h : Handle) : m String := do
     if line.length == 0 then pure s else read (s ++ line)
   read ""
 
-def readBinFile (fname : String) : m ByteArray := do
+def readBinFile (fname : FilePath) : m ByteArray := do
   let h ← Handle.mk fname Mode.read true
   h.readBinToEnd
 
-def readFile (fname : String) : m String := do
+def readFile (fname : FilePath) : m String := do
   let h ← Handle.mk fname Mode.read false
   h.readToEnd
 
-partial def lines (fname : String) : m (Array String) := do
+partial def lines (fname : FilePath) : m (Array String) := do
   let h ← Handle.mk fname Mode.read false
   let rec read (lines : Array String) := do
     let line ← h.getLine
@@ -253,23 +262,73 @@ partial def lines (fname : String) : m (Array String) := do
       pure <| lines.push line
   read #[]
 
-def writeBinFile (fname : String) (content : ByteArray) : m Unit := do
+def writeBinFile (fname : FilePath) (content : ByteArray) : m Unit := do
   let h ← Handle.mk fname Mode.write true
   h.write content
 
-def writeFile (fname : String) (content : String) : m Unit := do
+def writeFile (fname : FilePath) (content : String) : m Unit := do
   let h ← Handle.mk fname Mode.write false
   h.putStr content
 
-namespace Stream
-
-def putStrLn (strm : FS.Stream) (s : String) : m Unit :=
+def Stream.putStrLn (strm : FS.Stream) (s : String) : m Unit :=
   liftM (strm.putStr (s.push '\n'))
 
-end Stream
+structure DirEntry where
+  root     : FilePath
+  fileName : String
+  deriving Repr
+
+def DirEntry.path (entry : DirEntry) : FilePath :=
+  entry.root / entry.fileName
+
+inductive FileType where
+  | dir
+  | file
+  | symlink
+  | other
+  deriving Repr, BEq
+
+structure SystemTime where
+  sec  : Int
+  nsec : UInt32
+  deriving Repr, BEq, Ord, Inhabited
+
+instance : LT SystemTime := ltOfOrd
+instance : LE SystemTime := leOfOrd
+
+structure Metadata where
+  --permissions : ...
+  accessed : SystemTime
+  modified : SystemTime
+  byteSize : UInt64
+  type     : FileType
+  deriving Repr
 
 end FS
+end IO
 
+namespace System.FilePath
+open IO
+variable [Monad m] [MonadLiftT IO m]
+
+@[extern "lean_io_read_dir"]
+constant readDir : @& FilePath → IO (Array IO.FS.DirEntry)
+
+@[extern "lean_io_metadata"]
+constant metadata : @& FilePath → IO IO.FS.Metadata
+
+def isDir (p : FilePath) : IO Bool :=
+  try
+    return (← p.metadata).type == IO.FS.FileType.dir
+  catch _ =>
+    return false
+
+def pathExists (p : FilePath) : IO Bool :=
+  (p.metadata *> pure true) <|> pure false
+
+end System.FilePath
+
+namespace IO
 section
 variable [Monad m] [MonadLiftT IO m]
 
@@ -320,19 +379,35 @@ private def eprintlnAux (s : String) : IO Unit :=
   eprintln s
 
 def getEnv : String → m (Option String) := liftM ∘ Prim.getEnv
-def realPath : String → m String := liftM ∘ Prim.realPath
-def isDir : String → m Bool := liftM ∘ Prim.isDir
-def fileExists : String → m Bool := liftM ∘ Prim.fileExists
-def removeFile : String → m Unit := liftM ∘ Prim.removeFile
-def appPath : m String := liftM Prim.appPath
 
-def appDir : m String := do
+def realPath : FilePath → m FilePath := liftM ∘ Prim.realPath
+def removeFile : FilePath → m Unit := liftM ∘ Prim.removeFile
+def appPath : m FilePath := liftM Prim.appPath
+
+def appDir : m FilePath := do
   let p ← appPath
-  let some p ← pure <| System.FilePath.parent p
+  let some p ← pure p.parent
     | liftM (m := IO) <| throw <| IO.userError s!"System.IO.appDir: unexpected filename '{p}'"
   realPath p
 
-def currentDir : m String := liftM Prim.currentDir
+def currentDir : m FilePath := liftM Prim.currentDir
+
+@[extern "lean_io_create_dir"]
+constant createDir : @& FilePath → IO Unit
+
+partial def createDirAll (p : FilePath) : IO Unit := do
+  if ← p.isDir then
+    return ()
+  if let some parent := p.parent then
+    createDirAll parent
+  try
+    createDir p
+  catch
+    | e =>
+      if ← p.isDir then
+        pure ()  -- I guess someone else was faster
+      else
+        throw e
 
 end
 
@@ -361,7 +436,7 @@ structure SpawnArgs extends StdioConfig where
   /- Arguments for the process -/
   args : Array String := #[]
   /- Working directory for the process. Inherit from current process if `none`. -/
-  cwd : Option String := none
+  cwd : Option FilePath := none
   /- Add or remove environment variables for the process. -/
   env : Array (String × Option String) := #[]
 
@@ -420,9 +495,9 @@ def FileRight.flags (acc : FileRight) : UInt32 :=
   let o : UInt32 := acc.other.flags
   u.lor <| g.lor o
 
-@[extern "lean_chmod"] constant Prim.setAccessRights (filename : @& String) (mode : UInt32) : IO Unit
+@[extern "lean_chmod"] constant Prim.setAccessRights (filename : @& FilePath) (mode : UInt32) : IO Unit
 
-def setAccessRights (filename : String) (mode : FileRight) : IO Unit :=
+def setAccessRights (filename : FilePath) (mode : FileRight) : IO Unit :=
   Prim.setAccessRights filename mode.flags
 
 /- References -/
diff --git a/stage0/src/Lean/Data/Lsp/Ipc.lean b/stage0/src/Lean/Data/Lsp/Ipc.lean
index 7469cf43cf..615bbddb8f 100644
--- a/stage0/src/Lean/Data/Lsp/Ipc.lean
+++ b/stage0/src/Lean/Data/Lsp/Ipc.lean
@@ -69,11 +69,11 @@ partial def collectDiagnostics (waitForDiagnosticsId : RequestID := 0) (target :
     | _ => loop
   loop
 
-def runWith (cmd : String) (args : Array String := #[]) (test : IpcM α) : IO α := do
+def runWith (lean : System.FilePath) (args : Array String := #[]) (test : IpcM α) : IO α := do
   let proc ← Process.spawn {
     toStdioConfig := ipcStdioConfig
-    cmd := cmd
+    cmd := lean.toString
     args := args }
   ReaderT.run test proc
 
-end Lean.Lsp.Ipc
\ No newline at end of file
+end Lean.Lsp.Ipc
diff --git a/stage0/src/Lean/Elab/PreDefinition/Structural.lean b/stage0/src/Lean/Elab/PreDefinition/Structural.lean
index ec56bf6a64..5976a5b119 100644
--- a/stage0/src/Lean/Elab/PreDefinition/Structural.lean
+++ b/stage0/src/Lean/Elab/PreDefinition/Structural.lean
@@ -29,8 +29,24 @@ private def getFixedPrefix (declName : Name) (xs : Array Expr) (value : Expr) :
            ```
            The first three arguments at `V.map (fun b => α b) (fun b => β b) f Bool.false e` are "fixed"
            modulo definitional equality.
+
+           We disable to proof irrelevance to be able to use structural recursion on inductive predicates.
+           For example, consider the example
+           ```
+          inductive PList (α : Type) : Prop
+          | nil
+          | cons : α → PList α → PList α
+
+          infixr:67 " ::: " => PList.cons
+
+          set_option trace.Elab.definition.structural true in
+          def pmap {α β} (f : α → β) : PList α → PList β
+          | PList.nil => PList.nil
+          | a:::as => f a ::: pmap f as
+          ```
+          The "Fixed" prefix would be 4 since all elements of type `PList α` are definitionally equal.
         -/
-        if !(← withReducible <| isDefEq arg x) then
+        if !(← withoutProofIrrelevance <| withReducible <| isDefEq arg x) then
           -- We continue searching if e's arguments are not a prefix of `xs`
           return true
       return false
diff --git a/stage0/src/Lean/Environment.lean b/stage0/src/Lean/Environment.lean
index 88ecd08063..8aeb8a2641 100644
--- a/stage0/src/Lean/Environment.lean
+++ b/stage0/src/Lean/Environment.lean
@@ -466,9 +466,9 @@ instance : Inhabited ModuleData :=
   ⟨{imports := arbitrary, constants := arbitrary, entries := arbitrary }⟩
 
 @[extern 3 "lean_save_module_data"]
-constant saveModuleData (fname : @& String) (m : ModuleData) : IO Unit
+constant saveModuleData (fname : @& System.FilePath) (m : ModuleData) : IO Unit
 @[extern 2 "lean_read_module_data"]
-constant readModuleData (fname : @& String) : IO (ModuleData × CompactedRegion)
+constant readModuleData (fname : @& System.FilePath) : IO (ModuleData × CompactedRegion)
 
 /--
   Free compacted regions of imports. No live references to imported objects may exist at the time of invocation; in
@@ -508,7 +508,7 @@ def mkModuleData (env : Environment) : IO ModuleData := do
   }
 
 @[export lean_write_module]
-def writeModule (env : Environment) (fname : String) : IO Unit := do
+def writeModule (env : Environment) (fname : System.FilePath) : IO Unit := do
   let modData ← mkModuleData env; saveModuleData fname modData
 
 private partial def getEntriesFor (mod : ModuleData) (extId : Name) (i : Nat) : Array EnvExtensionEntry :=
@@ -581,7 +581,7 @@ where
     else do
       modify fun s => { s with moduleNameSet := s.moduleNameSet.insert i.module }
       let mFile ← findOLean i.module
-      unless (← IO.fileExists mFile) do
+      unless (← mFile.pathExists) do
         throw $ IO.userError s!"object file '{mFile}' of module {i.module} does not exist"
       let (mod, region) ← readModuleData mFile
       importMods mod.imports.toList
diff --git a/stage0/src/Lean/Meta/Basic.lean b/stage0/src/Lean/Meta/Basic.lean
index cd6a7fc920..fea3d4c869 100644
--- a/stage0/src/Lean/Meta/Basic.lean
+++ b/stage0/src/Lean/Meta/Basic.lean
@@ -56,6 +56,8 @@ structure Config where
   /- When `trackZeta == true`, we store zetaFVarIds all free variables that have been zeta-expanded. -/
   trackZeta          : Bool := false
   unificationHints   : Bool := true
+  /- Enables proof irrelevance at `isDefEq` -/
+  proofIrrelevance   : Bool := true
 
 structure ParamInfo where
   implicit     : Bool      := false
@@ -456,6 +458,9 @@ def elimMVarDeps (xs : Array Expr) (e : Expr) (preserveOrder : Bool := false) :
 @[inline] def withTrackingZeta (x : n α) : n α :=
   withConfig (fun cfg => { cfg with trackZeta := true }) x
 
+@[inline] def withoutProofIrrelevance (x : n α) : n α :=
+  withConfig (fun cfg => { cfg with proofIrrelevance := false }) x
+
 @[inline] def withTransparency (mode : TransparencyMode) : n α → n α :=
   mapMetaM <| withConfig (fun config => { config with transparency := mode })
 
diff --git a/stage0/src/Lean/Meta/ExprDefEq.lean b/stage0/src/Lean/Meta/ExprDefEq.lean
index 900988a1f3..5a5799ca47 100644
--- a/stage0/src/Lean/Meta/ExprDefEq.lean
+++ b/stage0/src/Lean/Meta/ExprDefEq.lean
@@ -1189,21 +1189,24 @@ private def isLetFVar (fvarId : FVarId) : MetaM Bool := do
   pure decl.isLet
 
 private def isDefEqProofIrrel (t s : Expr) : MetaM LBool := do
-  let status ← isProofQuick t
-  match status with
-  | LBool.false =>
-    pure LBool.undef
-  | LBool.true  =>
-    let tType ← inferType t
-    let sType ← inferType s
-    toLBoolM <| Meta.isExprDefEqAux tType sType
-  | LBool.undef =>
-    let tType ← inferType t
-    if (← isProp tType) then
+  if (← getConfig).proofIrrelevance then
+    let status ← isProofQuick t
+    match status with
+    | LBool.false =>
+      pure LBool.undef
+    | LBool.true  =>
+      let tType ← inferType t
       let sType ← inferType s
       toLBoolM <| Meta.isExprDefEqAux tType sType
-    else
-      pure LBool.undef
+    | LBool.undef =>
+      let tType ← inferType t
+      if (← isProp tType) then
+        let sType ← inferType s
+        toLBoolM <| Meta.isExprDefEqAux tType sType
+      else
+        pure LBool.undef
+  else
+    pure LBool.undef
 
 /- Try to solve constraint of the form `?m args₁ =?= ?m args₂`.
    - First try to unify `args₁` and `args₂`, and return true if successful
diff --git a/stage0/src/Lean/Meta/Injective.lean b/stage0/src/Lean/Meta/Injective.lean
index 34db9b6280..047da012dd 100644
--- a/stage0/src/Lean/Meta/Injective.lean
+++ b/stage0/src/Lean/Meta/Injective.lean
@@ -3,6 +3,7 @@ Copyright (c) 2021 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
+import Lean.Meta.Transform
 import Lean.Meta.Tactic.Injection
 import Lean.Meta.Tactic.Apply
 import Lean.Meta.Tactic.Cases
@@ -21,9 +22,17 @@ private def mkAnd? (args : Array Expr) : Option Expr := do
       result := mkApp2 (mkConst ``And) arg result
     return result
 
+def elimOptParam (type : Expr) : CoreM Expr := do
+  Core.transform type fun e =>
+    if e.isAppOfArity  ``optParam 2 then
+      return TransformStep.visit (e.getArg! 0)
+    else
+      return TransformStep.visit e
+
 private partial def mkInjectiveTheoremTypeCore? (ctorVal : ConstructorVal) (useEq : Bool) : MetaM (Option Expr) := do
   let us := ctorVal.levelParams.map mkLevelParam
-  forallBoundedTelescope ctorVal.type ctorVal.numParams fun params type =>
+  let type ← elimOptParam ctorVal.type
+  forallBoundedTelescope type ctorVal.numParams fun params type =>
   forallTelescope type fun args1 resultType => do
     let jp (args2 args2New : Array Expr) : MetaM (Option Expr) := do
       let lhs := mkAppN (mkAppN (mkConst ctorVal.name us) params) args1
diff --git a/stage0/src/Lean/Meta/Tactic/Apply.lean b/stage0/src/Lean/Meta/Tactic/Apply.lean
index 9423b9ecce..48a71788a2 100644
--- a/stage0/src/Lean/Meta/Tactic/Apply.lean
+++ b/stage0/src/Lean/Meta/Tactic/Apply.lean
@@ -101,7 +101,7 @@ def splitAnd (mvarId : MVarId) : MetaM (List MVarId) := do
   saturate mvarId fun mvarId =>
     observing? <| apply mvarId (mkConst ``And.intro)
 
-def applyRefl (mvarId : MVarId) (msg : MessageData) : MetaM Unit :=
+def applyRefl (mvarId : MVarId) (msg : MessageData := "refl failed") : MetaM Unit :=
   withMVarContext mvarId do
     let some [] ← observing? do apply mvarId (mkConst ``Eq.refl [← mkFreshLevelMVar])
       | throwTacticEx `refl mvarId msg
diff --git a/stage0/src/Lean/Meta/Tactic/Replace.lean b/stage0/src/Lean/Meta/Tactic/Replace.lean
index 5171638033..6d50ac8f76 100644
--- a/stage0/src/Lean/Meta/Tactic/Replace.lean
+++ b/stage0/src/Lean/Meta/Tactic/Replace.lean
@@ -5,6 +5,7 @@ Authors: Leonardo de Moura
 -/
 import Lean.Util.ForEachExpr
 import Lean.Meta.AppBuilder
+import Lean.Meta.MatchUtil
 import Lean.Meta.Tactic.Util
 import Lean.Meta.Tactic.Revert
 import Lean.Meta.Tactic.Intro
@@ -102,4 +103,16 @@ def changeLocalDecl (mvarId : MVarId) (fvarId : FVarId) (typeNew : Expr) (checkD
     | Expr.letE n t v b _  => do check t; finalize (mkLet n typeNew v b)
     | _ => throwTacticEx `changeHypothesis mvarId "unexpected auxiliary target"
 
+def modifyTarget (mvarId : MVarId) (f : Expr → MetaM Expr) : MetaM MVarId := do
+  withMVarContext mvarId do
+    checkNotAssigned mvarId `modifyTarget
+    change mvarId (← f (← getMVarType mvarId)) (checkDefEq := false)
+
+def modifyTargetEqLHS (mvarId : MVarId) (f : Expr → MetaM Expr) : MetaM MVarId := do
+   modifyTarget mvarId fun target => do
+     if let some (_, lhs, rhs) ← matchEq? target then
+       mkEq (← f lhs) rhs
+     else
+       throwTacticEx `modifyTargetEqLHS mvarId m!"equality expected{indentExpr target}"
+
 end Lean.Meta
diff --git a/stage0/src/Lean/MonadEnv.lean b/stage0/src/Lean/MonadEnv.lean
index c727074d64..a6170d685d 100644
--- a/stage0/src/Lean/MonadEnv.lean
+++ b/stage0/src/Lean/MonadEnv.lean
@@ -122,6 +122,8 @@ def addDecl [Monad m] [MonadEnv m] [MonadError m] [MonadOptions m] (decl : Decla
 private def supportedRecursors :=
   #[``Empty.rec, ``False.rec, ``Eq.rec, ``Eq.recOn, ``Eq.casesOn, ``False.casesOn, ``Empty.casesOn, ``And.rec, ``And.casesOn]
 
+/- This is a temporary workaround for generating better error messages for the compiler. It can be deleted after we
+   rewrite the remaining parts of the compiler in Lean.  -/
 private def checkUnsupported [Monad m] [MonadEnv m] [MonadError m] (decl : Declaration) : m Unit := do
   let env ← getEnv
   decl.forExprM fun e =>
@@ -137,8 +139,10 @@ private def checkUnsupported [Monad m] [MonadEnv m] [MonadError m] (decl : Decla
 def compileDecl [Monad m] [MonadEnv m] [MonadError m] [MonadOptions m] (decl : Declaration) : m Unit := do
   match (← getEnv).compileDecl (← getOptions) decl with
   | Except.ok env   => setEnv env
+  | Except.error (KernelException.other msg) =>
+    checkUnsupported decl -- Generate nicer error message for unsupported recursors and axioms
+    throwError msg
   | Except.error ex =>
-    checkUnsupported decl -- Generate nicer error message for unsupported recursors
     throwKernelException ex
 
 def addAndCompile [Monad m] [MonadEnv m] [MonadError m] [MonadOptions m] (decl : Declaration) : m Unit := do
diff --git a/stage0/src/Lean/Parser/Module.lean b/stage0/src/Lean/Parser/Module.lean
index b853ef4cf2..f12cd4929f 100644
--- a/stage0/src/Lean/Parser/Module.lean
+++ b/stage0/src/Lean/Parser/Module.lean
@@ -116,16 +116,15 @@ partial def testParseModuleAux (env : Environment) (inputCtx : InputContext) (s
   parse s msgs stxs
 
 def testParseModule (env : Environment) (fname contents : String) : IO Syntax := do
-  let fname ← IO.realPath fname
   let inputCtx := mkInputContext contents fname
   let (header, state, messages) ← parseHeader inputCtx
   let cmds ← testParseModuleAux env inputCtx state messages #[]
   let stx := Syntax.node `Lean.Parser.Module.module #[header, mkListNode cmds]
   pure stx.updateLeading
 
-def testParseFile (env : Environment) (fname : String) : IO Syntax := do
+def testParseFile (env : Environment) (fname : System.FilePath) : IO Syntax := do
   let contents ← IO.FS.readFile fname
-  testParseModule env fname contents
+  testParseModule env fname.toString contents
 
 end Parser
 end Lean
diff --git a/stage0/src/Lean/PrettyPrinter.lean b/stage0/src/Lean/PrettyPrinter.lean
index 472f010027..05f5fc9f78 100644
--- a/stage0/src/Lean/PrettyPrinter.lean
+++ b/stage0/src/Lean/PrettyPrinter.lean
@@ -12,7 +12,8 @@ import Lean.ParserCompiler
 namespace Lean
 
 def PPContext.runCoreM {α : Type} (ppCtx : PPContext) (x : CoreM α) : IO α :=
-  Prod.fst <$> x.toIO { options := ppCtx.opts, currNamespace := ppCtx.currNamespace, openDecls := ppCtx.openDecls } { env := ppCtx.env }
+  Prod.fst <$> x.toIO { options := ppCtx.opts, currNamespace := ppCtx.currNamespace, openDecls := ppCtx.openDecls }
+                      { env := ppCtx.env, ngen := { namePrefix := `_pp_uniq } }
 
 def PPContext.runMetaM {α : Type} (ppCtx : PPContext) (x : MetaM α) : IO α :=
   ppCtx.runCoreM <| x.run' { lctx := ppCtx.lctx } { mctx := ppCtx.mctx }
diff --git a/stage0/src/Lean/PrettyPrinter/Delaborator/Builtins.lean b/stage0/src/Lean/PrettyPrinter/Delaborator/Builtins.lean
index 0ef3d7c117..85771f7e96 100644
--- a/stage0/src/Lean/PrettyPrinter/Delaborator/Builtins.lean
+++ b/stage0/src/Lean/PrettyPrinter/Delaborator/Builtins.lean
@@ -200,21 +200,37 @@ where
       x
 
 /-- Skip `numParams` binders, and execute `x varNames` where `varNames` contains the new binder names. -/
-private def skippingBinders {α} (numParams : Nat) (x : Array Name → DelabM α) : DelabM α :=
+private partial def skippingBinders {α} (numParams : Nat) (x : Array Name → DelabM α) : DelabM α :=
   loop numParams #[]
 where
   loop : Nat → Array Name → DelabM α
     | 0,   varNames => x varNames
     | n+1, varNames => do
-      let varName ← (← getExpr).bindingName!.eraseMacroScopes
-      -- Pattern variables cannot shadow each other
-      if varNames.contains varName then
-        let varName := (← getLCtx).getUnusedName varName
-        withBindingBody varName do
-          loop n (varNames.push varName)
+      let rec visitLambda : DelabM α := do
+        let varName ← (← getExpr).bindingName!.eraseMacroScopes
+        -- Pattern variables cannot shadow each other
+        if varNames.contains varName then
+          let varName := (← getLCtx).getUnusedName varName
+          withBindingBody varName do
+            loop n (varNames.push varName)
+        else
+          withBindingBodyUnusedName fun id => do
+            loop n (varNames.push id.getId)
+      let e ← getExpr
+      if e.isLambda then
+        visitLambda
       else
-        withBindingBodyUnusedName fun id => do
-          loop n (varNames.push id.getId)
+        -- eta expand `e`
+        let e ← forallTelescopeReducing (← inferType e) fun xs _ => do
+          if xs.size == 1 && (← inferType xs[0]).isConstOf ``Unit then
+            -- `e` might be a thunk create by the dependent pattern matching compiler, and `xs[0]` may not even be a pattern variable.
+            -- If it is a pattern variable, it doesn't look too bad to use `()` instead of the pattern variable.
+            -- If it becomes a problem in the future, we should modify the dependent pattern matching compiler, and make sure
+            -- it adds an annotation to distinguish these two cases.
+            mkLambdaFVars xs (mkApp e (mkConst ``Unit.unit))
+          else
+            mkLambdaFVars xs (mkAppN e xs)
+        withReader (fun ctx => { ctx with expr := e }) visitLambda
 
 /--
   Delaborate applications of "matchers" such as
diff --git a/stage0/src/Lean/Server/FileWorker.lean b/stage0/src/Lean/Server/FileWorker.lean
index 27eaff8177..99a3817de5 100644
--- a/stage0/src/Lean/Server/FileWorker.lean
+++ b/stage0/src/Lean/Server/FileWorker.lean
@@ -152,12 +152,12 @@ section Initialization
   /-- Use `leanpkg print-paths` to compile dependencies on the fly and add them to `LEAN_PATH`.
   Compilation progress is reported to `hOut` via LSP notifications. Return the search path for
   source files. -/
-  partial def leanpkgSetupSearchPath (leanpkgPath : String) (m : DocumentMeta) (imports : Array Import) (hOut : FS.Stream) : IO SearchPath := do
+  partial def leanpkgSetupSearchPath (leanpkgPath : System.FilePath) (m : DocumentMeta) (imports : Array Import) (hOut : FS.Stream) : IO SearchPath := do
     let leanpkgProc ← Process.spawn {
       stdin  := Process.Stdio.null
       stdout := Process.Stdio.piped
       stderr := Process.Stdio.piped
-      cmd    := leanpkgPath
+      cmd    := leanpkgPath.toString
       args   := #["print-paths"] ++ imports.map (toString ·.module)
     }
     -- progress notification: report latest stderr line
@@ -172,13 +172,17 @@ section Initialization
     let stdout := String.trim (← leanpkgProc.stdout.readToEnd)
     let stderr ← IO.ofExcept stderr.get
     if (← leanpkgProc.wait) == 0 then
-      match stdout.split (· == '\n') with
+      let leanpkgLines := stdout.split (· == '\n')
+      -- ignore any output up to the last two lines
+      -- TODO: leanpkg should instead redirect nested stdout output to stderr
+      let leanpkgLines := leanpkgLines.drop (leanpkgLines.length - 2)
+      match leanpkgLines with
       | [""]                    => pure []  -- e.g. no leanpkg.toml
       | [leanPath, leanSrcPath] => let sp ← getBuiltinSearchPath
                                    let sp ← addSearchPathFromEnv sp
-                                   let sp ← parseSearchPath leanPath sp
+                                   let sp := System.SearchPath.parse leanPath ++ sp
                                    searchPathRef.set sp
-                                   let srcPath := parseSearchPath leanSrcPath
+                                   let srcPath := System.SearchPath.parse leanSrcPath
                                    srcPath.mapM realPathNormalized
       | _                       => throw <| IO.userError s!"unexpected output from `leanpkg print-paths`:\n{stdout}\nstderr:\n{stderr}"
     else
@@ -189,21 +193,22 @@ section Initialization
     let inputCtx := Parser.mkInputContext m.text.source "<input>"
     let (headerStx, headerParserState, msgLog) ← Parser.parseHeader inputCtx
     let leanpkgPath ← match ← IO.getEnv "LEAN_SYSROOT" with
-      | some path => s!"{path}/bin/leanpkg{System.FilePath.exeSuffix}"
-      | _         => s!"{← appDir}/leanpkg{System.FilePath.exeSuffix}"
-    let mut srcSearchPath := [s!"{← appDir}/../lib/lean/src"]
+      | some path => pure <| System.FilePath.mk path / "bin" / "leanpkg"
+      | _         => pure <| (← appDir) / "leanpkg"
+    let leanpkgPath := leanpkgPath.withExtension System.FilePath.exeExtension
+    let mut srcSearchPath := [(← appDir) / ".." / "lib" / "lean" / "src"]
     if let some p := (← IO.getEnv "LEAN_SRC_PATH") then
-      srcSearchPath := srcSearchPath ++ parseSearchPath p
+      srcSearchPath := srcSearchPath ++ System.SearchPath.parse p
     let (headerEnv, msgLog) ← try
       -- NOTE: leanpkg does not exist in stage 0 (yet?)
-      if (← fileExists leanpkgPath) then
+      if (← System.FilePath.pathExists leanpkgPath) then
         let pkgSearchPath ← leanpkgSetupSearchPath leanpkgPath m (Lean.Elab.headerToImports headerStx).toArray hOut
         srcSearchPath := srcSearchPath ++ pkgSearchPath
       Elab.processHeader headerStx opts msgLog inputCtx
     catch e =>  -- should be from `leanpkg print-paths`
       let msgs := MessageLog.empty.add { fileName := "<ignored>", pos := ⟨0, 0⟩, data := e.toString }
-      publishMessages m msgs hOut
       pure (← mkEmptyEnvironment, msgs)
+    publishMessages m msgLog hOut
     let cmdState := Elab.Command.mkState headerEnv msgLog opts
     let cmdState := { cmdState with infoState.enabled := true, scopes := [{ header := "", opts := opts }] }
     let headerSnap := {
@@ -411,7 +416,7 @@ section RequestHandling
               let mod? ← ci.runMetaM i.lctx <| findModuleOf? n
               let modUri? ← match mod? with
                 | some modName =>
-                  let modFname? ← st.srcSearchPath.findWithExt ".lean" modName
+                  let modFname? ← st.srcSearchPath.findWithExt "lean" modName
                   pure <| modFname?.map toFileUri
                 | none         => pure <| some doc.meta.uri
 
diff --git a/stage0/src/Lean/Server/Utils.lean b/stage0/src/Lean/Server/Utils.lean
index 6259c5e4ee..a0d29c4a33 100644
--- a/stage0/src/Lean/Server/Utils.lean
+++ b/stage0/src/Lean/Server/Utils.lean
@@ -91,8 +91,8 @@ def maybeTee (fName : String) (isOut : Bool) (h : FS.Stream) : IO FS.Stream := d
       h.chainRight hTee true
 
 /-- Transform the given path to a file:// URI. -/
-def toFileUri (fname : String) : Lsp.DocumentUri :=
-  let fname := System.FilePath.normalizePath fname
+def toFileUri (fname : System.FilePath) : Lsp.DocumentUri :=
+  let fname := fname.normalize.toString
   let fname := if System.Platform.isWindows then
     fname.map fun c => if c == '\\' then '/' else c
   else
diff --git a/stage0/src/Lean/Server/Watchdog.lean b/stage0/src/Lean/Server/Watchdog.lean
index 190303b4ad..dbfa4d2c31 100644
--- a/stage0/src/Lean/Server/Watchdog.lean
+++ b/stage0/src/Lean/Server/Watchdog.lean
@@ -178,7 +178,7 @@ section ServerM
     /-- We store these to pass them to workers. -/
     initParams     : InitializeParams
     editDelay      : Nat
-    workerPath     : String
+    workerPath     : System.FilePath
 
   abbrev ServerM := ReaderT ServerContext IO
 
@@ -234,7 +234,7 @@ section ServerM
     let headerAst ← parseHeaderAst m.text.source
     let workerProc ← Process.spawn {
       toStdioConfig := workerCfg
-      cmd           := st.workerPath
+      cmd           := st.workerPath.toString
       args          := #["--worker"] ++ st.args.toArray
     }
     let pendingRequestsRef ← IO.mkRef (RBMap.empty : PendingRequestMap)
@@ -553,9 +553,9 @@ def initAndRunWatchdogAux : ServerM Unit := do
 def initAndRunWatchdog (args : List String) (i o e : FS.Stream) : IO Unit := do
   let mut workerPath ← IO.appPath
   if let some path := (←IO.getEnv "LEAN_SYSROOT") then
-    workerPath := s!"{path}/bin/lean{System.FilePath.exeSuffix}"
+    workerPath := System.FilePath.mk path / "bin" / "lean" |>.withExtension System.FilePath.exeExtension
   if let some path := (←IO.getEnv "LEAN_WORKER_PATH") then
-    workerPath := path
+    workerPath := System.FilePath.mk path
   let fileWorkersRef ← IO.mkRef (RBMap.empty : FileWorkerMap)
   let i ← maybeTee "wdIn.txt" false i
   let o ← maybeTee "wdOut.txt" true o
diff --git a/stage0/src/Lean/Util/Path.lean b/stage0/src/Lean/Util/Path.lean
index 77b5e0029c..7be0af5257 100644
--- a/stage0/src/Lean/Util/Path.lean
+++ b/stage0/src/Lean/Util/Path.lean
@@ -11,72 +11,73 @@ with a directory `A/`. `import A` resolves to `path/A.olean`.
 import Lean.Data.Name
 
 namespace Lean
-open System.FilePath (pathSeparator extSeparator)
-private def pathSep : String := toString pathSeparator
+open System
 
-def realPathNormalized (fname : String) : IO String := do
-  let fname ← IO.realPath fname
-  pure (System.FilePath.normalizePath fname)
+def realPathNormalized (p : FilePath) : IO FilePath := do
+  (← IO.realPath p).normalize
 
-def modPathToFilePath : Name → String
-  | Name.str p h _              => modPathToFilePath p ++ pathSep ++ h
-  | Name.anonymous              => ""
-  | Name.num p _ _              => panic! "ill-formed import"
+def modToFilePath (base : FilePath) (mod : Name) (ext : String) : FilePath :=
+  go mod |>.withExtension ext
+where
+  go : Name → FilePath
+  | Name.str p h _ => go p / h
+  | Name.anonymous => base
+  | Name.num p _ _ => panic! "ill-formed import"
 
-abbrev SearchPath := List String
+/-- A `.olean' search path. -/
+abbrev SearchPath := System.SearchPath
 
 namespace SearchPath
 
 /-- If the package of `mod` can be found in `sp`, return the path with extension
-`ext` (`.lean` or `.olean`) corresponding to `mod`. Otherwise, return `none.` -/
-def findWithExt (sp : SearchPath) (ext : String) (mod : Name) : IO (Option String) := do
+`ext` (`lean` or `olean`) corresponding to `mod`. Otherwise, return `none.` -/
+def findWithExt (sp : SearchPath) (ext : String) (mod : Name) : IO (Option FilePath) := do
   let pkg := mod.getRoot.toString
-  let root? ← sp.findM? (fun path =>
-    IO.isDir s!"{path}{pathSep}{pkg}" <||> IO.fileExists s!"{path}{pathSep}{pkg}{ext}")
-  return root?.map (· ++ modPathToFilePath mod ++ ext)
+  let root? ← sp.findM? fun p =>
+    (p / pkg).isDir <||> ((p / pkg).withExtension ext).pathExists
+  return root?.map (modToFilePath · mod ext)
 
 end SearchPath
 
 builtin_initialize searchPathRef : IO.Ref SearchPath ← IO.mkRef {}
 
-def parseSearchPath (path : String) (sp : SearchPath := ∅) : SearchPath :=
-  System.FilePath.splitSearchPath path ++ sp
-
 @[extern c inline "LEAN_IS_STAGE0"]
 private constant isStage0 (u : Unit) : Bool
 
 def getBuiltinSearchPath : IO SearchPath := do
   let appDir ← IO.appDir
+  let mut buildDir := appDir / ".."
   -- use stage1 stdlib with stage0 executable (which should never be distributed outside of the build directory)
-  pure [appDir ++ pathSep ++ ".." ++ (if isStage0 () then pathSep ++ ".." ++ pathSep ++ "stage1" else "") ++ pathSep ++ "lib" ++ pathSep ++ "lean"]
+  if isStage0 () then
+    buildDir := buildDir / ".." / "stage1"
+  [buildDir / "lib" / "lean"]
 
 def addSearchPathFromEnv (sp : SearchPath) : IO SearchPath := do
   let val ← IO.getEnv "LEAN_PATH"
   match val with
   | none     => pure sp
-  | some val => parseSearchPath val sp
+  | some val => pure <| SearchPath.parse val ++ sp
 
 @[export lean_init_search_path]
 def initSearchPath (path : Option String := none) : IO Unit :=
   match path with
-  | some path => searchPathRef.set <| parseSearchPath path
+  | some path => searchPathRef.set <| SearchPath.parse path
   | none      => do
     let sp ← getBuiltinSearchPath
     let sp ← addSearchPathFromEnv sp
     searchPathRef.set sp
 
-partial def findOLean (mod : Name) : IO String := do
+partial def findOLean (mod : Name) : IO FilePath := do
   let sp ← searchPathRef.get
-  if let some fname ← sp.findWithExt ".olean" mod then
+  if let some fname ← sp.findWithExt "olean" mod then
     return fname
   else
-    let pkg := mod.getRoot
+    let pkg := FilePath.mk mod.getRoot.toString
     let mut msg := s!"unknown package '{pkg}'"
     let rec maybeThisOne dir := do
-      let pkgdir := s!"{dir}{pathSep}{pkg}"
-      if ← IO.fileExists pkgdir then
+      if ← (pkg / dir).isDir then
         return some s!"\nYou might need to open '{dir}' as a workspace in your editor"
-      if let some dir ← System.FilePath.parent dir then
+      if let some dir ← dir.parent then
         maybeThisOne dir
       else
        return none
@@ -86,22 +87,20 @@ partial def findOLean (mod : Name) : IO String := do
 
 /-- Infer module name of source file name. -/
 @[export lean_module_name_of_file]
-def moduleNameOfFileName (fname : String) (rootDir : Option String) : IO Name := do
-  let fname ← realPathNormalized fname
+def moduleNameOfFileName (fname : FilePath) (rootDir : Option FilePath) : IO Name := do
+  let fname ← IO.realPath fname
   let rootDir ← match rootDir with
     | some rootDir => pure rootDir
     | none         => IO.currentDir
-  let rootDir ← realPathNormalized rootDir
-  if !rootDir.isPrefixOf fname then
+  let mut rootDir ← realPathNormalized rootDir
+  if !rootDir.toString.endsWith System.FilePath.pathSeparator.toString then
+    rootDir := ⟨rootDir.toString ++ System.FilePath.pathSeparator.toString⟩
+  if !rootDir.toString.isPrefixOf fname.normalize.toString then
     throw $ IO.userError s!"input file '{fname}' must be contained in root directory ({rootDir})"
-  let fnameSuffix := fname.drop rootDir.length
-  let fnameSuffix := if fnameSuffix.get 0 == pathSeparator then fnameSuffix.drop 1 else fnameSuffix
-  let some extPos ← pure (fnameSuffix.revPosOf '.')
-    | throw (IO.userError ("failed to convert file name '" ++ fname ++ "' to module name, extension is missing"))
-  let modNameStr := fnameSuffix.extract 0 extPos
-  let extStr     := fnameSuffix.extract (extPos + 1) fnameSuffix.bsize
-  let parts      := modNameStr.splitOn pathSep
-  let modName    := parts.foldl Name.mkStr Name.anonymous
+  -- NOTE: use `fname` instead of `fname.normalize` to preserve casing on all platforms
+  let fnameSuffix := fname.toString.drop rootDir.toString.length
+  let modNameStr := FilePath.mk fnameSuffix |>.withExtension ""
+  let modName    := modNameStr.components.foldl Name.mkStr Name.anonymous
   pure modName
 
 end Lean
diff --git a/stage0/src/Leanpkg.lean b/stage0/src/Leanpkg.lean
index 68d01dd728..74559d0344 100644
--- a/stage0/src/Leanpkg.lean
+++ b/stage0/src/Leanpkg.lean
@@ -5,6 +5,9 @@ Authors: Gabriel Ebner, Sebastian Ullrich
 -/
 import Leanpkg.Resolve
 import Leanpkg.Git
+import Leanpkg.Build
+
+open System
 
 namespace Leanpkg
 
@@ -15,10 +18,10 @@ def readManifest : IO Manifest := do
        ++ ", but package requires " ++ m.leanVersion ++ "\n"
   return m
 
-def writeManifest (manifest : Lean.Syntax) (fn : String) : IO Unit := do
+def writeManifest (manifest : Lean.Syntax) (fn : FilePath) : IO Unit := do
   IO.FS.writeFile fn manifest.reprint.get!
 
-def lockFileName := ".leanpkg-lock"
+def lockFileName : System.FilePath := ⟨".leanpkg-lock"⟩
 
 partial def withLockFile (x : IO α) : IO α := do
   acquire
@@ -36,7 +39,7 @@ partial def withLockFile (x : IO α) : IO α := do
           -- `x` mode doesn't seem to work on Windows even though it's listed at
           -- https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-wfopen?view=msvc-160
           -- ...? Let's use the slightly racy approach then.
-          if ← IO.fileExists lockFileName then
+          if ← lockFileName.pathExists then
             throw <| IO.Error.alreadyExists 0 ""
           discard <| IO.Prim.Handle.mk lockFileName "w"
       catch
@@ -47,56 +50,76 @@ partial def withLockFile (x : IO α) : IO α := do
           acquire (firstTime := false)
         | e => throw e
 
+def getRootPart (pkg : FilePath := ".") : IO Lean.Name := do
+  let entries ← pkg.readDir
+  match entries.filter (FilePath.extension ·.fileName == "lean") with
+  | #[rootFile] => FilePath.withExtension rootFile.fileName "" |>.toString
+  | #[]         => throw <| IO.userError s!"no '.lean' file found in {← IO.realPath "."}"
+  | _           => throw <| IO.userError s!"{← IO.realPath "."} must contain a unique '.lean' file as the package root"
+
 structure Configuration :=
   leanPath    : String
   leanSrcPath : String
+  moreDeps    : List FilePath
 
 def configure : IO Configuration := do
   let d ← readManifest
   IO.eprintln $ "configuring " ++ d.name ++ " " ++ d.version
   let assg ← solveDeps d
   let paths ← constructPath assg
+  let mut moreDeps := [leanpkgTomlFn]
   for path in paths do
-    unless path == "./." do
+    unless path == FilePath.mk "." / "." do
       -- build recursively
       -- TODO: share build of common dependencies
       execCmd {
-        cmd := (← IO.appPath)
+        cmd := (← IO.appPath).toString
         cwd := path
         args := #["build"]
       }
-  let sep := System.FilePath.searchPathSeparator.toString
+      moreDeps := (path / Build.buildPath / (← getRootPart path).toString |>.withExtension "olean") :: moreDeps
   return {
-    leanPath    := sep.intercalate <| paths.map (· ++ "/build")
-    leanSrcPath := sep.intercalate paths
+    leanPath    := SearchPath.toString <| paths.map (· / Build.buildPath)
+    leanSrcPath := SearchPath.toString paths
+    moreDeps
   }
 
-def execMake (makeArgs leanArgs : List String) (leanPath : String) : IO Unit := withLockFile do
+def execMake (makeArgs : List String) (cfg : Build.Config) : IO Unit := withLockFile do
   let manifest ← readManifest
-  let leanArgs := (match manifest.timeout with | some t => ["-T", toString t] | none => []) ++ leanArgs
+  let leanArgs := (match manifest.timeout with | some t => ["-T", toString t] | none => []) ++ cfg.leanArgs
   let mut spawnArgs := {
     cmd := "sh"
     cwd := manifest.effectivePath
-    args := #["-c", s!"\"{← IO.appDir}/leanmake\" LEAN_OPTS=\"{" ".intercalate leanArgs}\" LEAN_PATH=\"{leanPath}\" {" ".intercalate makeArgs} >&2"]
+    args := #["-c", s!"\"{← IO.appDir}/leanmake\" PKG={cfg.pkg} LEAN_OPTS=\"{" ".intercalate leanArgs}\" LEAN_PATH=\"{cfg.leanPath}\" {" ".intercalate makeArgs} MORE_DEPS+=\"{" ".intercalate (cfg.moreDeps.map toString)}\" >&2"]
   }
   execCmd spawnArgs
 
 def buildImports (imports : List String) (leanArgs : List String) : IO Unit := do
-  unless (← IO.fileExists leanpkgTomlFn) do
+  unless ← leanpkgTomlFn.pathExists do
     return
   let manifest ← readManifest
   let cfg ← configure
   let imports := imports.map (·.toName)
-  -- TODO: shoddy check
-  let localImports := imports.filter fun i => i.getRoot.toString.toLower == manifest.name.toLower
+  let root ← getRootPart
+  let localImports := imports.filter (·.getRoot == root)
   if localImports != [] then
-    let oleans := localImports.map fun i => s!"\"build{Lean.modPathToFilePath i}.olean\""
-    execMake oleans leanArgs cfg.leanPath
+    let buildCfg : Build.Config := { pkg := root, leanArgs, leanPath := cfg.leanPath, moreDeps := cfg.moreDeps }
+    if ← FilePath.pathExists "Makefile" then
+      let oleans := localImports.map fun i => Lean.modToFilePath "build" i "olean" |>.toString
+      execMake oleans buildCfg
+    else
+      Build.buildModules buildCfg localImports
   IO.println cfg.leanPath
   IO.println cfg.leanSrcPath
 
 def build (makeArgs leanArgs : List String) : IO Unit := do
-  execMake makeArgs leanArgs (← configure).leanPath
+  let cfg ← configure
+  let root ← getRootPart
+  let buildCfg : Build.Config := { pkg := root, leanArgs, leanPath := cfg.leanPath, moreDeps := cfg.moreDeps }
+  if makeArgs != [] || (← FilePath.pathExists "Makefile") then
+    execMake makeArgs buildCfg
+  else
+    Build.buildModules buildCfg [root]
 
 def initGitignoreContents :=
   "/build
@@ -108,13 +131,12 @@ name = \"{n}\"
 version = \"0.1\"
 lean_version = \"{leanVersionString}\"
 "
-  IO.FS.writeFile s!"{n.capitalize}.lean" "def main : IO Unit :=
+  IO.FS.writeFile ⟨s!"{n.capitalize}.lean"⟩ "def main : IO Unit :=
   IO.println \"Hello, world!\"
 "
-  let h ← IO.FS.Handle.mk ".gitignore" IO.FS.Mode.append (bin := false)
+  let h ← IO.FS.Handle.mk ⟨".gitignore"⟩ IO.FS.Mode.append (bin := false)
   h.putStr initGitignoreContents
-  let gitEx ← IO.isDir ".git"
-  unless gitEx do
+  unless ← System.FilePath.isDir ⟨".git"⟩ do
     (do
       execCmd {cmd := "git", args := #["init", "-q"]}
       unless upstreamGitBranch = "master" do
@@ -195,7 +217,12 @@ def splitCmdlineArgs : List String → IO (String × List String × List String)
 
 end Leanpkg
 
-def main (args : List String) : IO Unit := do
-  Lean.initSearchPath none  -- HACK
-  let (cmd, outerArgs, innerArgs) ← Leanpkg.splitCmdlineArgs args
-  Leanpkg.main cmd outerArgs innerArgs
+def main (args : List String) : IO UInt32 := do
+  try
+    Lean.initSearchPath none  -- HACK
+    let (cmd, outerArgs, innerArgs) ← Leanpkg.splitCmdlineArgs args
+    Leanpkg.main cmd outerArgs innerArgs
+    pure 0
+  catch e =>
+    IO.eprintln e  -- avoid "uncaught exception: ..."
+    pure 1
diff --git a/stage0/src/Leanpkg/Build.lean b/stage0/src/Leanpkg/Build.lean
new file mode 100644
index 0000000000..423f89023b
--- /dev/null
+++ b/stage0/src/Leanpkg/Build.lean
@@ -0,0 +1,102 @@
+/-
+Copyright (c) 2021 Sebastian Ullrich. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Sebastian Ullrich
+-/
+import Lean.Data.Name
+import Lean.Elab.Import
+import Leanpkg.Proc
+
+open Lean
+open System
+
+namespace Leanpkg.Build
+
+def buildPath : FilePath := "build"
+def tempBuildPath := buildPath / "temp"
+
+structure Config where
+  pkg      : Name
+  leanArgs : List String
+  leanPath : String
+  -- things like `leanpkg.toml` and olean roots of dependencies that should also trigger rebuilds
+  moreDeps : List FilePath
+
+structure Context extends Config where
+  parents       : List Name := []
+  moreDepsMTime : IO.FS.SystemTime
+
+structure Result where
+  maxMTime : IO.FS.SystemTime
+  task     : Task (Except IO.Error Unit)
+  deriving Inhabited
+
+structure State where
+  modTasks : NameMap Result := ∅
+
+abbrev BuildM := ReaderT Context <| StateT State IO
+
+partial def buildModule (mod : Name) : BuildM Result := do
+  let ctx ← read
+  if ctx.parents.contains mod then
+    -- cyclic import
+    let cycle := ctx.parents.dropWhile (· != mod) ++ [mod]
+    let cycle := cycle.reverse.map (s!"  {·}")
+    throw <| IO.userError s!"import cycle detected:\n{"\n".intercalate cycle}"
+
+  if let some r := (← get).modTasks.find? mod then
+    -- already visited
+    return r
+
+  let leanFile := modToFilePath "." mod "lean"
+  let leanMData ← leanFile.metadata
+
+  -- recursively build dependencies and calculate transitive `maxMTime`
+  let (imports, _, _) ← Elab.parseImports (← IO.FS.readFile leanFile) leanFile.toString
+  let localImports := imports.filter (·.module.getRoot == ctx.pkg)
+  let deps ← localImports.mapM (buildModule ·.module)
+  let depMTimes ← deps.mapM (·.maxMTime)
+  let maxMTime := List.maximum? (leanMData.modified :: ctx.moreDepsMTime :: depMTimes) |>.get!
+
+  -- check whether we have an up-to-date .olean
+  let oleanFile := modToFilePath buildPath mod "olean"
+  try
+    if (← oleanFile.metadata).modified >= maxMTime then
+      let r := { maxMTime, task := Task.pure (Except.ok ()) }
+      modify fun st => { st with modTasks := st.modTasks.insert mod r }
+      return r
+  catch
+    | IO.Error.noFileOrDirectory .. => pure ()
+    | e                             => throw e
+
+  let task ← IO.mapTasks (tasks := deps.map (·.task)) fun rs => do
+    if let some e := rs.findSome? (fun | Except.error e => some e | Except.ok _ => none) then
+      -- propagate failure
+      throw e
+    try
+      let cFile := modToFilePath tempBuildPath mod "c"
+      IO.createDirAll oleanFile.parent.get!
+      IO.createDirAll cFile.parent.get!
+      execCmd {
+        cmd := (← IO.appDir) / "lean" |>.withExtension FilePath.exeExtension |>.toString
+        args := ctx.leanArgs.toArray ++ #["-o", oleanFile.toString, "-c", cFile.toString, leanFile.toString]
+        env := #[("LEAN_PATH", ctx.leanPath)]
+      }
+    catch e =>
+      -- print errors early
+      IO.eprintln e
+      throw e
+
+  let r := { maxMTime, task := task }
+  modify fun st => { st with modTasks := st.modTasks.insert mod r }
+  return r
+
+def buildModules (cfg : Config) (mods : List Name) : IO Unit := do
+  let moreDepsMTime := (← cfg.moreDeps.mapM (·.metadata)).map (·.modified) |>.maximum? |>.getD ⟨0, 0⟩
+  let rs ← mods.mapM buildModule |>.run { toConfig := cfg, moreDepsMTime } |>.run' {}
+  for r in rs do
+    if let Except.error _ ← IO.wait r.task then
+      -- actual error has already been printed above
+      throw <| IO.userError "Build failed."
+
+end Leanpkg.Build
diff --git a/stage0/src/Leanpkg/Git.lean b/stage0/src/Leanpkg/Git.lean
index a2ebcdcc8f..55ce109228 100644
--- a/stage0/src/Leanpkg/Git.lean
+++ b/stage0/src/Leanpkg/Git.lean
@@ -5,6 +5,8 @@ Authors: Gabriel Ebner, Sebastian Ullrich
 -/
 import Leanpkg.LeanVersion
 
+open System
+
 namespace Leanpkg
 
 def upstreamGitBranch :=
@@ -14,24 +16,24 @@ def gitdefaultRevision : Option String → String
   | none => upstreamGitBranch
   | some branch => branch
 
-def gitParseRevision (gitRepoDir : String) (rev : String) : IO String := do
-  let rev ← IO.Process.run {cmd := "git", args := #["rev-parse", "-q", "--verify", rev], cwd := gitRepoDir}
+def gitParseRevision (gitRepo : FilePath) (rev : String) : IO String := do
+  let rev ← IO.Process.run {cmd := "git", args := #["rev-parse", "-q", "--verify", rev], cwd := gitRepo}
   rev.trim -- remove newline at end
 
-def gitHeadRevision (gitRepoDir : String) : IO String :=
-  gitParseRevision gitRepoDir "HEAD"
+def gitHeadRevision (gitRepo : FilePath) : IO String :=
+  gitParseRevision gitRepo "HEAD"
 
-def gitParseOriginRevision (gitRepoDir : String) (rev : String) : IO String :=
-  (gitParseRevision gitRepoDir $ "origin/" ++ rev) <|> gitParseRevision gitRepoDir rev
-    <|> throw (IO.userError s!"cannot find revision {rev} in repository {gitRepoDir}")
+def gitParseOriginRevision (gitRepo : FilePath) (rev : String) : IO String :=
+  (gitParseRevision gitRepo $ "origin/" ++ rev) <|> gitParseRevision gitRepo rev
+    <|> throw (IO.userError s!"cannot find revision {rev} in repository {gitRepo}")
 
-def gitLatestOriginRevision (gitRepoDir : String) (branch : Option String) : IO String := do
-  discard <| IO.Process.run {cmd := "git", args := #["fetch"], cwd := gitRepoDir}
-  gitParseOriginRevision gitRepoDir (gitdefaultRevision branch)
+def gitLatestOriginRevision (gitRepo : FilePath) (branch : Option String) : IO String := do
+  discard <| IO.Process.run {cmd := "git", args := #["fetch"], cwd := gitRepo}
+  gitParseOriginRevision gitRepo (gitdefaultRevision branch)
 
-def gitRevisionExists (gitRepoDir : String) (rev : String) : IO Bool := do
+def gitRevisionExists (gitRepo : FilePath) (rev : String) : IO Bool := do
   try
-    discard <| gitParseRevision gitRepoDir (rev ++ "^{commit}")
+    discard <| gitParseRevision gitRepo (rev ++ "^{commit}")
     true
   catch _ => false
 
diff --git a/stage0/src/Leanpkg/Manifest.lean b/stage0/src/Leanpkg/Manifest.lean
index a941e92b02..50caaafe4e 100644
--- a/stage0/src/Leanpkg/Manifest.lean
+++ b/stage0/src/Leanpkg/Manifest.lean
@@ -6,17 +6,19 @@ Authors: Gabriel Ebner, Sebastian Ullrich
 import Leanpkg.Toml
 import Leanpkg.LeanVersion
 
+open System
+
 namespace Leanpkg
 
 inductive Source where
-  | path (dirName : String) : Source
+  | path (dir : System.FilePath) : Source
   | git (url rev : String) (branch : Option String) : Source
 
 namespace Source
 
 def fromToml (v : Toml.Value) : Option Source :=
-  (do let Toml.Value.str dirName ← v.lookup "path" | none
-      path dirName) <|>
+  (do let Toml.Value.str dir ← v.lookup "path" | none
+      path ⟨dir⟩) <|>
   (do let Toml.Value.str url ← v.lookup "git" | none
       let Toml.Value.str rev ← v.lookup "rev" | none
       match v.lookup "branch" with
@@ -25,7 +27,7 @@ def fromToml (v : Toml.Value) : Option Source :=
       | _ => none)
 
 def toToml : Source → Toml.Value
-  | path dirName => Toml.Value.table [("path", Toml.Value.str dirName)]
+  | path dir => Toml.Value.table [("path", Toml.Value.str dir.toString)]
   | git url rev none =>
     Toml.Value.table [("git", Toml.Value.str url), ("rev", Toml.Value.str rev)]
   | git url rev (some branch) =>
@@ -42,13 +44,13 @@ structure Manifest where
   version : String
   leanVersion : String := leanVersionString
   timeout : Option Nat := none
-  path : Option String := none
+  path : Option FilePath := none
   dependencies : List Dependency := []
 
 namespace Manifest
 
-def effectivePath (m : Manifest) : String :=
-  m.path.getD "."
+def effectivePath (m : Manifest) : FilePath :=
+  m.path.getD ⟨"."⟩
 
 def fromToml (t : Toml.Value) : Option Manifest := OptionM.run do
   let pkg ← t.lookup "package"
@@ -63,7 +65,7 @@ def fromToml (t : Toml.Value) : Option Manifest := OptionM.run do
     | none => some none
     | _ => none
   let path ← match pkg.lookup "path" with
-    | some (Toml.Value.str path) => some (some path)
+    | some (Toml.Value.str path) => some (some ⟨path⟩)
     | none => some none
     | _ => none
   let Toml.Value.table deps ← t.lookup "dependencies" <|> some (Toml.Value.table []) | none
@@ -71,7 +73,7 @@ def fromToml (t : Toml.Value) : Option Manifest := OptionM.run do
   return { name := n, version := ver, leanVersion := leanVer,
            path := path, dependencies := deps, timeout := tm }
 
-def fromFile (fn : String) : IO Manifest := do
+def fromFile (fn : System.FilePath) : IO Manifest := do
   let cnts ← IO.FS.readFile fn
   let toml ← Toml.parse cnts
   let some manifest ← pure (fromToml toml)
@@ -80,6 +82,6 @@ def fromFile (fn : String) : IO Manifest := do
 
 end Manifest
 
-def leanpkgTomlFn := "leanpkg.toml"
+def leanpkgTomlFn : System.FilePath := ⟨"leanpkg.toml"⟩
 
 end Leanpkg
diff --git a/stage0/src/Leanpkg/Proc.lean b/stage0/src/Leanpkg/Proc.lean
index aeb5c05b44..cd4db43195 100644
--- a/stage0/src/Leanpkg/Proc.lean
+++ b/stage0/src/Leanpkg/Proc.lean
@@ -10,7 +10,7 @@ def execCmd (args : IO.Process.SpawnArgs) : IO Unit := do
   let cmdstr := " ".intercalate (args.cmd :: args.args.toList)
   IO.eprintln <| "> " ++ envstr ++
     match args.cwd with
-    | some cwd => cmdstr ++ "    # in directory " ++ cwd
+    | some cwd => s!"{cmdstr}    # in directory {cwd}"
     | none     => cmdstr
   let child ← IO.Process.spawn args
   let exitCode ← child.wait
diff --git a/stage0/src/Leanpkg/Resolve.lean b/stage0/src/Leanpkg/Resolve.lean
index 6afc734be1..57f76c1b02 100644
--- a/stage0/src/Leanpkg/Resolve.lean
+++ b/stage0/src/Leanpkg/Resolve.lean
@@ -7,9 +7,11 @@ import Leanpkg.Manifest
 import Leanpkg.Proc
 import Leanpkg.Git
 
+open System
+
 namespace Leanpkg
 
-def Assignment := List (String × String)
+def Assignment := List (String × FilePath)
 
 namespace Assignment
 def empty : Assignment := []
@@ -17,10 +19,10 @@ def empty : Assignment := []
 def contains (a : Assignment) (s : String) : Bool :=
   (a.lookup s).isSome
 
-def insert (a : Assignment) (k v : String) : Assignment :=
+def insert (a : Assignment) (k : String) (v : FilePath) : Assignment :=
   if a.contains k then a else (k, v) :: a
 
-def fold {α} (i : α) (f : α → String → String → α) : Assignment → α :=
+def fold {α} (i : α) (f : α → String → FilePath → α) : Assignment → α :=
   List.foldl (fun a ⟨k, v⟩ => f a k v) i
 
 end Assignment
@@ -30,27 +32,19 @@ abbrev Solver := StateT Assignment IO
 def notYetAssigned (d : String) : Solver Bool := do
   ¬ (← get).contains d
 
-def resolvedPath (d : String) : Solver String := do
+def resolvedPath (d : String) : Solver FilePath := do
   let some path ← pure ((← get).lookup d) | unreachable!
   path
 
--- TODO(gabriel): windows?
-def resolveDir (absOrRel : String) (base : String) : String :=
-  if absOrRel.front = '/' then
-    absOrRel -- absolute
-  else
-    base ++ "/" ++ absOrRel
-
-def materialize (relpath : String) (dep : Dependency) : Solver Unit :=
+def materialize (relpath : FilePath) (dep : Dependency) : Solver Unit :=
   match dep.src with
   | Source.path dir => do
-    let depdir := resolveDir dir relpath
+    let depdir := dir / relpath
     IO.eprintln s!"{dep.name}: using local path {depdir}"
     modify (·.insert dep.name depdir)
   | Source.git url rev branch => do
-    let depdir := "build/deps/" ++ dep.name
-    let alreadyThere ← IO.isDir depdir
-    if alreadyThere then
+    let depdir := FilePath.mk "build" / "deps" / dep.name
+    if ← depdir.isDir then
       IO.eprint s!"{dep.name}: trying to update {depdir} to revision {rev}"
       IO.eprintln (match branch with | none => "" | some branch => "@" ++ branch)
       let hash ← gitParseOriginRevision depdir rev
@@ -59,33 +53,32 @@ def materialize (relpath : String) (dep : Dependency) : Solver Unit :=
         execCmd {cmd := "git", args := #["fetch"], cwd := depdir}
     else
       IO.eprintln s!"{dep.name}: cloning {url} to {depdir}"
-      execCmd {cmd := "git", args := #["clone", url, depdir]}
+      execCmd {cmd := "git", args := #["clone", url, depdir.toString]}
     let hash ← gitParseOriginRevision depdir rev
     execCmd {cmd := "git", args := #["checkout", "--detach", hash], cwd := depdir}
     modify (·.insert dep.name depdir)
 
-def solveDepsCore (relPath : String) (d : Manifest) : (maxDepth : Nat) → Solver Unit
+def solveDepsCore (relPath : FilePath) (d : Manifest) : (maxDepth : Nat) → Solver Unit
   | 0 => throw <| IO.userError "maximum dependency resolution depth reached"
   | maxDepth + 1 => do
     let deps ← d.dependencies.filterM (notYetAssigned ·.name)
     deps.forM (materialize relPath)
     for dep in deps do
       let p ← resolvedPath dep.name
-      let d' ← Manifest.fromFile $ p ++ "/" ++ "leanpkg.toml"
+      let d' ← Manifest.fromFile $ p / "leanpkg.toml"
       unless d'.name = dep.name do
-        throw <| IO.userError <| d.name ++ " (in " ++ relPath ++ ") depends on " ++ d'.name ++
-          ", but resolved dependency has name " ++ dep.name ++ " (in " ++ p ++ ")"
+        throw <| IO.userError s!"{d.name} (in {relPath}) depends on {d'.name}, but resolved dependency has name {dep.name} (in {p})"
       solveDepsCore p d' maxDepth
 
 def solveDeps (d : Manifest) : IO Assignment := do
-  let (_, assg) ← (solveDepsCore "." d 1024).run <| Assignment.empty.insert d.name "."
+  let (_, assg) ← (solveDepsCore ⟨"."⟩ d 1024).run <| Assignment.empty.insert d.name ⟨"."⟩
   assg
 
-def constructPathCore (depname : String) (dirname : String) : IO String := do
-  let path ← Manifest.effectivePath (← Manifest.fromFile $ dirname ++ "/" ++ leanpkgTomlFn)
-  return dirname ++ "/" ++ path
+def constructPathCore (depname : String) (dirname : FilePath) : IO FilePath := do
+  let path ← Manifest.effectivePath (← Manifest.fromFile <| dirname / leanpkgTomlFn)
+  return dirname / path
 
-def constructPath (assg : Assignment) : IO (List String) := do
+def constructPath (assg : Assignment) : IO (List FilePath) := do
   assg.reverse.mapM fun ⟨depname, dirname⟩ => constructPathCore depname dirname
 
 end Leanpkg
diff --git a/stage0/src/include/lean/lean.h b/stage0/src/include/lean/lean.h
index 6065f362a9..e6a2291ff1 100644
--- a/stage0/src/include/lean/lean.h
+++ b/stage0/src/include/lean/lean.h
@@ -1744,6 +1744,7 @@ static inline uint64_t lean_uint64_modn(uint64_t a1, b_lean_obj_arg a2) {
 static inline uint8_t lean_uint64_dec_eq(uint64_t a1, uint64_t a2) { return a1 == a2; }
 static inline uint8_t lean_uint64_dec_lt(uint64_t a1, uint64_t a2) { return a1 < a2; }
 static inline uint8_t lean_uint64_dec_le(uint64_t a1, uint64_t a2) { return a1 <= a2; }
+uint64_t lean_uint64_mix_hash(uint64_t a1, uint64_t a2);
 
 /* USize */
 
diff --git a/stage0/src/kernel/local_ctx.cpp b/stage0/src/kernel/local_ctx.cpp
index 10c651c7d6..8849505dec 100644
--- a/stage0/src/kernel/local_ctx.cpp
+++ b/stage0/src/kernel/local_ctx.cpp
@@ -45,7 +45,7 @@ extern "C" object * lean_mk_empty_local_ctx(object*);
 extern "C" object * lean_local_ctx_num_indices(object*);
 extern "C" uint8 lean_local_ctx_is_empty(object*);
 extern "C" object * lean_local_ctx_mk_local_decl(object * lctx, object * name, object * user_name, object * expr, uint8 bi);
-extern "C" object * lean_local_ctx_mk_let_decl(object * lctx, object * name, object * user_name, object * type, object * value);
+extern "C" object * lean_local_ctx_mk_let_decl(object * lctx, object * name, object * user_name, object * type, object * value, uint8 non_dep);
 extern "C" object * lean_local_ctx_find(object * lctx, object * name);
 extern "C" object * lean_local_ctx_erase(object * lctx, object * name);
 
@@ -58,7 +58,7 @@ bool local_ctx::empty() const {
 
 local_decl local_ctx::mk_local_decl(name const & n, name const & un, expr const & type, expr const & value) {
     unsigned idx = unbox(lean_local_ctx_num_indices(to_obj_arg()));
-    m_obj = lean_local_ctx_mk_let_decl(raw(), n.to_obj_arg(), un.to_obj_arg(), type.to_obj_arg(), value.to_obj_arg());
+    m_obj = lean_local_ctx_mk_let_decl(raw(), n.to_obj_arg(), un.to_obj_arg(), type.to_obj_arg(), value.to_obj_arg(), false);
     return local_decl(idx, n, un, type, value);
 }
 
diff --git a/stage0/src/library/compiler/ll_infer_type.cpp b/stage0/src/library/compiler/ll_infer_type.cpp
index 9fa58c1496..71e1202732 100644
--- a/stage0/src/library/compiler/ll_infer_type.cpp
+++ b/stage0/src/library/compiler/ll_infer_type.cpp
@@ -199,7 +199,7 @@ class ll_infer_type_fn {
                 }
                 return *g_bot;
             }
-            throw exception(sstream() << "compiler failed to infer low level type, unknown declaration '" << const_name(e) << "'");
+            throw exception(sstream() << "failed to compile definition, consider marking it as 'noncomputable' because it depends on '" << const_name(e) << "', and it does not have executable code");
         }
     }
 
diff --git a/stage0/src/runtime/io.cpp b/stage0/src/runtime/io.cpp
index fd87fe6c9d..a33b723a82 100644
--- a/stage0/src/runtime/io.cpp
+++ b/stage0/src/runtime/io.cpp
@@ -2,7 +2,7 @@
 Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 
-Author: Leonardo de Moura
+Authors: Leonardo de Moura, Sebastian Ullrich
 */
 #if defined(LEAN_WINDOWS)
 #include <windows.h>
@@ -18,6 +18,7 @@ Author: Leonardo de Moura
 #ifndef LEAN_WINDOWS
 #include <csignal>
 #endif
+#include <dirent.h>
 #include <fcntl.h>
 #include <iostream>
 #include <chrono>
@@ -453,19 +454,98 @@ extern "C" obj_res lean_io_realpath(obj_arg fname, obj_arg) {
 #endif
 }
 
-extern "C" obj_res lean_io_is_dir(b_obj_arg fname, obj_arg) {
-    struct stat st;
-    if (stat(string_cstr(fname), &st) == 0) {
-        bool b = S_ISDIR(st.st_mode);
-        return io_result_mk_ok(box(b));
-    } else {
-        return io_result_mk_ok(box(0));
+/*
+structure DirEntry where
+  root     : String
+  filename : String
+
+constant readDir : @& FilePath → IO (Array DirEntry)
+*/
+extern "C" obj_res lean_io_read_dir(b_obj_arg dirname, obj_arg) {
+    object * arr = array_mk_empty();
+    DIR * dp = opendir(string_cstr(dirname));
+    if (!dp) {
+        return io_result_mk_error(decode_io_error(errno, dirname));
     }
+    while (dirent * entry = readdir(dp)) {
+        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+            continue;
+        }
+        object * lentry = alloc_cnstr(0, 2, 0);
+        lean_inc(dirname);
+        cnstr_set(lentry, 0, dirname);
+        cnstr_set(lentry, 1, lean_mk_string(entry->d_name));
+        arr = lean_array_push(arr, lentry);
+    }
+    lean_always_assert(closedir(dp) == 0);
+    return io_result_mk_ok(arr);
 }
 
-extern "C" obj_res lean_io_file_exists(b_obj_arg fname, obj_arg) {
-    bool b = !!std::ifstream(string_cstr(fname));
-    return io_result_mk_ok(box(b));
+/*
+inductive FileType where
+  | dir
+  | file
+  | symlink
+  | other
+
+structure SystemTime where
+  sec  : Int
+  nsec : UInt32
+
+structure Metadata where
+  --permissions : ...
+  accessed : SystemTime
+  modified : SystemTime
+  byteSize : UInt64
+  type     : FileType
+
+constant metadata : @& FilePath → IO IO.FS.Metadata
+*/
+static obj_res timespec_to_obj(timespec const & ts) {
+    object * o = alloc_cnstr(0, 1, sizeof(uint32));
+    cnstr_set(o, 0, lean_int64_to_int(ts.tv_sec));
+    cnstr_set_uint32(o, sizeof(object *), ts.tv_nsec);
+    return o;
+}
+
+extern "C" obj_res lean_io_metadata(b_obj_arg fname, obj_arg) {
+    struct stat st;
+    if (stat(string_cstr(fname), &st) != 0) {
+        return io_result_mk_error(decode_io_error(errno, fname));
+    }
+    object * mdata = alloc_cnstr(0, 2, sizeof(uint64) + sizeof(uint8));
+#ifdef __APPLE__
+    cnstr_set(mdata, 0, timespec_to_obj(st.st_atimespec));
+    cnstr_set(mdata, 1, timespec_to_obj(st.st_mtimespec));
+#elif defined(LEAN_WINDOWS)
+    // TOOD: sub-second precision on Windows
+    cnstr_set(mdata, 0, timespec_to_obj(timespec { st.st_atime, 0 }));
+    cnstr_set(mdata, 1, timespec_to_obj(timespec { st.st_mtime, 0 }));
+#else
+    cnstr_set(mdata, 0, timespec_to_obj(st.st_atim));
+    cnstr_set(mdata, 1, timespec_to_obj(st.st_mtim));
+#endif
+    cnstr_set_uint64(mdata, 2 * sizeof(object *), st.st_size);
+    cnstr_set_uint8(mdata, 2 * sizeof(object *) + sizeof(uint64),
+                    S_ISDIR(st.st_mode) ? 0 :
+                    S_ISREG(st.st_mode) ? 1 :
+#ifndef LEAN_WINDOWS
+                    S_ISLNK(st.st_mode) ? 2 :
+#endif
+                    3);
+    return io_result_mk_ok(mdata);
+}
+
+extern "C" obj_res lean_io_create_dir(b_obj_arg p, obj_arg) {
+#ifdef LEAN_WINDOWS
+    if (mkdir(string_cstr(p)) == 0) {
+#else
+    if (mkdir(string_cstr(p), 0777) == 0) {
+#endif
+        return io_result_mk_ok(box(0));
+    } else {
+        return io_result_mk_error(decode_io_error(errno, p));
+    }
 }
 
 extern "C" obj_res lean_io_remove_file(b_obj_arg fname, obj_arg) {
@@ -708,7 +788,7 @@ extern "C" obj_res lean_io_wait(obj_arg t, obj_arg) {
     return io_result_mk_ok(lean_task_get_own(t));
 }
 
-extern "C" obj_res lean_io_wait_any(b_obj_arg task_list) {
+extern "C" obj_res lean_io_wait_any(b_obj_arg task_list, obj_arg) {
     object * t = lean_io_wait_any_core(task_list);
     object * v = lean_task_get(t);
     lean_inc(v);
diff --git a/stage0/src/runtime/object.cpp b/stage0/src/runtime/object.cpp
index de2127414a..fc05fa9b44 100644
--- a/stage0/src/runtime/object.cpp
+++ b/stage0/src/runtime/object.cpp
@@ -1471,6 +1471,10 @@ extern "C" uint64 lean_uint64_big_modn(uint64 a1, b_lean_obj_arg) {
     return a1;
 }
 
+extern "C" uint64 lean_uint64_mix_hash(uint64 a1, uint64 a2) {
+  return hash(a1, a2);
+}
+
 extern "C" usize lean_usize_of_big_nat(b_obj_arg a) {
     return mpz_value(a).get_size_t();
 }
diff --git a/stage0/src/shell/CMakeLists.txt b/stage0/src/shell/CMakeLists.txt
index d2b79a457f..093302f825 100644
--- a/stage0/src/shell/CMakeLists.txt
+++ b/stage0/src/shell/CMakeLists.txt
@@ -139,4 +139,11 @@ ENDFOREACH(T)
 
 add_test(NAME leanpkgtest
          WORKING_DIRECTORY "${LEAN_SOURCE_DIR}/../tests/leanpkg/b"
-         COMMAND bash -c "PATH=${LEAN_BIN}:$PATH leanpkg build")
+         COMMAND bash -c "
+           set -eu
+           export PATH=${LEAN_BIN}:$PATH
+           leanpkg build
+           # linking requires some manual steps
+           (cd ../a; leanpkg build lib)
+           leanpkg build bin LINK_OPTS=../a/build/lib/libA.a
+           ./build/bin/B")
diff --git a/stage0/stdlib/Init/Control/Option.c b/stage0/stdlib/Init/Control/Option.c
index 12fca2f098..48e3902c1e 100644
--- a/stage0/stdlib/Init/Control/Option.c
+++ b/stage0/stdlib/Init/Control/Option.c
@@ -15,10 +15,13 @@ extern "C" {
 #endif
 lean_object* l_OptionT_instMonadOptionT(lean_object*);
 lean_object* l_OptionT_instAlternativeOptionT(lean_object*);
+lean_object* l_OptionT_mk___rarg___boxed(lean_object*);
 lean_object* l_OptionT_instMonadOptionT___rarg___lambda__9___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_tryCatch(lean_object*);
 lean_object* l_OptionT_bind___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_instMonadLiftOptionT(lean_object*);
+lean_object* l_OptionT_instMonadExceptOfOptionT(lean_object*, lean_object*, lean_object*);
+lean_object* l_OptionT_instMonadExceptOfOptionT___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_bind(lean_object*);
 lean_object* l_OptionT_run___rarg(lean_object*);
 lean_object* l_OptionT_orElse___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -37,6 +40,7 @@ lean_object* l_OptionT_run___rarg___boxed(lean_object*);
 lean_object* l_OptionT_instMonadExceptOfUnitOptionT___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_instMonadExceptOfUnitOptionT___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_tryCatch___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_OptionT_instMonadExceptOfOptionT___rarg(lean_object*);
 lean_object* l_OptionT_instMonadOptionT___rarg___lambda__10(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_bind_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_instMonadOptionT___rarg___lambda__3(lean_object*, lean_object*, lean_object*);
@@ -46,6 +50,8 @@ lean_object* l_OptionT_instMonadOptionT___rarg___lambda__9(lean_object*, lean_ob
 lean_object* l_OptionT_bind_match__1(lean_object*, lean_object*);
 lean_object* l_OptionT_instMonadLiftOptionT___rarg(lean_object*);
 lean_object* l_OptionT_lift___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_OptionT_mk___rarg(lean_object*);
+lean_object* l_instMonadExceptOfExceptT___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_pure(lean_object*);
 lean_object* l_OptionT_pure___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_instToBoolOption___closed__1;
@@ -60,7 +66,9 @@ lean_object* l_OptionT_instMonadOptionT___rarg___lambda__7(lean_object*, lean_ob
 lean_object* l_OptionT_instMonadFunctorOptionT___rarg(lean_object*, lean_object*);
 lean_object* l_OptionT_instMonadOptionT___rarg(lean_object*);
 lean_object* l_OptionT_fail(lean_object*);
+lean_object* l_OptionT_mk(lean_object*, lean_object*);
 lean_object* l_OptionT_instMonadOptionT___rarg___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_instMonadExceptOfExceptT___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_instMonadOptionT___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_orElse_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_OptionT_fail___rarg(lean_object*, lean_object*);
@@ -106,6 +114,30 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_OptionT_mk___rarg(lean_object* x_1) {
+_start:
+{
+lean_inc(x_1);
+return x_1;
+}
+}
+lean_object* l_OptionT_mk(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_OptionT_mk___rarg___boxed), 1, 0);
+return x_3;
+}
+}
+lean_object* l_OptionT_mk___rarg___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_OptionT_mk___rarg(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
 lean_object* l_OptionT_bind_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -878,6 +910,38 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_OptionT_instMonadExceptOfOptionT___rarg(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+lean_inc(x_1);
+x_2 = lean_alloc_closure((void*)(l_instMonadExceptOfExceptT___rarg___lambda__1), 3, 1);
+lean_closure_set(x_2, 0, x_1);
+x_3 = lean_alloc_closure((void*)(l_instMonadExceptOfExceptT___rarg___lambda__2), 4, 1);
+lean_closure_set(x_3, 0, x_1);
+x_4 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_4, 0, x_2);
+lean_ctor_set(x_4, 1, x_3);
+return x_4;
+}
+}
+lean_object* l_OptionT_instMonadExceptOfOptionT(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_OptionT_instMonadExceptOfOptionT___rarg), 1, 0);
+return x_4;
+}
+}
+lean_object* l_OptionT_instMonadExceptOfOptionT___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_OptionT_instMonadExceptOfOptionT(x_1, x_2, x_3);
+lean_dec(x_3);
+return x_4;
+}
+}
 lean_object* l_OptionM_run___rarg(lean_object* x_1) {
 _start:
 {
diff --git a/stage0/stdlib/Init/Core.c b/stage0/stdlib/Init/Core.c
index f6d7f43aa4..224c310594 100644
--- a/stage0/stdlib/Init/Core.c
+++ b/stage0/stdlib/Init/Core.c
@@ -21,6 +21,7 @@ extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_1585
 lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(lean_object*, lean_object*);
 lean_object* l_Thunk_map(lean_object*, lean_object*);
 lean_object* l_instDecidableArrow___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_instInhabitedTask___rarg(lean_object*);
 lean_object* l_Quotient_hrecOn___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Quotient_lift(lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_1116____closed__2;
@@ -48,7 +49,6 @@ lean_object* l_instDecidableEqSum___rarg(lean_object*, lean_object*, lean_object
 lean_object* l_Lean_reduceBool___boxed(lean_object*);
 lean_object* l_term___u2260_____closed__4;
 lean_object* l_Subtype_instDecidableEqSubtype(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1492____closed__4;
 lean_object* l_instDecidableIff___rarg___boxed(lean_object*, lean_object*);
 extern lean_object* l_term___u2218_____closed__6;
 uint8_t l_decidableOfDecidableOfEq___rarg(uint8_t, lean_object*);
@@ -60,15 +60,14 @@ lean_object* l_term___x21_x3d_____closed__2;
 lean_object* l_term___u2260_____closed__1;
 lean_object* l_Quot_liftOn___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_instDecidableEqProd_match__2(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__5;
 lean_object* l_Eq_mpr___rarg___boxed(lean_object*);
 lean_object* l_Thunk_map___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_instBEqProd(lean_object*, lean_object*);
 uint8_t l_instDecidableTrue;
+lean_object* l_myMacro____x40_Init_Core___hyg_1508____closed__6;
 lean_object* l_instDecidableEqQuotient_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_term_x7b_x7d___closed__1;
 lean_object* l_Quotient_recOnSubsingleton___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1492____closed__2;
 lean_object* l_instInhabitedForInStep(lean_object*);
 lean_object* l_instDecidableEqQuotient_match__1___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_term_x7b_x7d___closed__2;
@@ -77,12 +76,12 @@ lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_184____closed__3;
 lean_object* lean_task_spawn(lean_object*, lean_object*);
 lean_object* l_instDecidableEqPUnit___boxed(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1492____closed__1;
 uint8_t l_instDecidableEqPUnit(lean_object*, lean_object*);
 lean_object* l_term___u2260_____closed__5;
 lean_object* l_term___x21_x3d_____closed__3;
 lean_object* l_term___u2260_____closed__3;
 lean_object* l_prodHasDecidableLt___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__5;
 lean_object* l_myMacro____x40_Init_Core___hyg_898____closed__1;
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_898____closed__6;
@@ -104,6 +103,7 @@ lean_object* l_instHasEquiv(lean_object*, lean_object*);
 lean_object* l_Quotient_lift_u2082___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_term___u2194_____closed__2;
 lean_object* l_Task_bind___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1508____closed__2;
 lean_object* lean_thunk_pure(lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_1997____closed__4;
 lean_object* l_myMacro____x40_Init_Core___hyg_898____closed__5;
@@ -116,16 +116,17 @@ lean_object* l_Subtype_instDecidableEqSubtype___rarg(lean_object*, lean_object*,
 lean_object* l_term___x3c_x2d_x3e_____closed__6;
 lean_object* l_Quotient_mk___boxed(lean_object*, lean_object*);
 lean_object* l_instDecidableEqQuotient___boxed(lean_object*, lean_object*);
+lean_object* l_instInhabitedTask(lean_object*);
 lean_object* l_Thunk_bind___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_instDecidableDite___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_term___u2260_____closed__6;
-lean_object* l_myMacro____x40_Init_Core___hyg_1492____closed__6;
 lean_object* l_Eq_mpr(lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_1116____closed__1;
 lean_object* l_Quot_recOn___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Thunk_get___boxed(lean_object*, lean_object*);
 lean_object* l_term___u2194_____closed__4;
 lean_object* l_Quot_recOnSubsingleton(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1508____closed__4;
 lean_object* l_Lean_reduceNat(lean_object*);
 lean_object* l_Squash_lift___rarg(lean_object*, lean_object*);
 lean_object* l_Sum_inhabitedLeft___rarg(lean_object*);
@@ -133,11 +134,12 @@ lean_object* l_Quotient_lift_u2082___boxed(lean_object*, lean_object*, lean_obje
 uint8_t l_instDecidableIte___rarg(uint8_t, uint8_t, uint8_t);
 lean_object* l_instDecidableEqQuotient_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Quot_hrecOn(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1508____closed__1;
 lean_object* l_myMacro____x40_Init_Core___hyg_898_(lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_1116_(lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_401_(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1874_(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1492_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1890_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1508_(lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_1231_(lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_184_(lean_object*, lean_object*, lean_object*);
 lean_object* l_term_x7b_x7d___closed__6;
@@ -161,7 +163,6 @@ lean_object* l_instDecidableEqProd_match__2___rarg(lean_object*, lean_object*);
 lean_object* l_instInhabitedProp;
 lean_object* l_flip___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Quotient_hrecOn___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1492____closed__5;
 lean_object* l_Quotient_rec(lean_object*, lean_object*, lean_object*);
 lean_object* l_Quotient_liftOn_u2082___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_1116____closed__6;
@@ -171,12 +172,11 @@ lean_object* l_unexpand____x40_Init_Core___hyg_882_(lean_object*, lean_object*);
 lean_object* l_unexpand____x40_Init_Core___hyg_1102_(lean_object*);
 lean_object* l_unexpand____x40_Init_Core___hyg_385_(lean_object*, lean_object*);
 lean_object* l_unexpand____x40_Init_Core___hyg_168_(lean_object*, lean_object*);
-lean_object* l_unexpand____x40_Init_Core___hyg_1476_(lean_object*, lean_object*);
-lean_object* l_unexpand____x40_Init_Core___hyg_1858_(lean_object*, lean_object*);
+lean_object* l_unexpand____x40_Init_Core___hyg_1874_(lean_object*, lean_object*);
+lean_object* l_unexpand____x40_Init_Core___hyg_1492_(lean_object*, lean_object*);
 lean_object* l_instDecidableIff(lean_object*, lean_object*);
 uint8_t l_instDecidableIff___rarg(uint8_t, uint8_t);
 lean_object* l_term___x3c_x2d_x3e_____closed__5;
-lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__4;
 lean_object* l_term_x7b_x7d___closed__3;
 lean_object* l_term___u2194__;
 uint8_t l_strictOr(uint8_t, uint8_t);
@@ -188,7 +188,6 @@ lean_object* l_decidableOfDecidableOfEq(lean_object*, lean_object*);
 lean_object* l_unexpand____x40_Init_Core___hyg_1221____boxed(lean_object*);
 lean_object* l_instDecidableEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Squash_mk(lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__6;
 lean_object* lean_mk_thunk(lean_object*);
 lean_object* l_term_u2205___closed__4;
 extern lean_object* l_Lean_Parser_Syntax_addPrec___closed__10;
@@ -206,6 +205,7 @@ lean_object* l_Thunk_map___rarg___lambda__1(lean_object*, lean_object*, lean_obj
 lean_object* l_instBEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_term_x7b_x7d___closed__5;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 lean_object* l_myMacro____x40_Init_Core___hyg_184____closed__6;
 extern lean_object* l_Lean_nullKind___closed__2;
 lean_object* l_Squash_lift(lean_object*, lean_object*, lean_object*);
@@ -215,10 +215,12 @@ lean_object* l_term___x3c_x2d_x3e_____closed__3;
 lean_object* l_term___u2194_____closed__5;
 lean_object* l_Eq_mp(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isNodeOf(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__6;
 extern lean_object* l_term___x3c_x3d_____closed__5;
 lean_object* l_toBoolUsing(lean_object*);
 lean_object* l_Subtype_instDecidableEqSubtype_match__1(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
+lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__1;
 lean_object* l_term_u2205___closed__3;
 lean_object* l_Subtype_instInhabitedSubtype___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Decidable_byCases_match__1___rarg(uint8_t, lean_object*, lean_object*);
@@ -234,15 +236,13 @@ lean_object* lean_task_bind(lean_object*, lean_object*, lean_object*);
 lean_object* l_Thunk_bind___rarg(lean_object*, lean_object*);
 uint8_t l_bne___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_myMacro____x40_Init_Core___hyg_1116____closed__9;
-lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__1;
 lean_object* l_instDecidableEqSum(lean_object*, lean_object*);
 lean_object* l_Subtype_instInhabitedSubtype(lean_object*, lean_object*);
 lean_object* l_Quot_recOnSubsingleton___rarg(lean_object*, lean_object*);
 lean_object* l_Sum_inhabitedLeft(lean_object*, lean_object*);
 lean_object* l_Quotient_mk___rarg___boxed(lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__2;
+lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__2;
 lean_object* l_Eq_mp___rarg(lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1492____closed__3;
 lean_object* l_instHasEquiv___boxed(lean_object*, lean_object*);
 lean_object* l_Quotient_liftOn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_inline___rarg___boxed(lean_object*);
@@ -259,6 +259,8 @@ lean_object* l_Quot_rec(lean_object*, lean_object*, lean_object*);
 lean_object* l_Decidable_byCases_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Subtype_instDecidableEqSubtype_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Task_Priority_max;
+lean_object* l_myMacro____x40_Init_Core___hyg_1508____closed__3;
+lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__3;
 lean_object* l_instDecidableEqSum_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Decidable_byCases_match__1(lean_object*, lean_object*);
 lean_object* l_Lean_reduceNat___boxed(lean_object*);
@@ -266,6 +268,7 @@ lean_object* l_Thunk_bind___rarg___lambda__1(lean_object*, lean_object*, lean_ob
 lean_object* l_unexpand____x40_Init_Core___hyg_1102____rarg(lean_object*);
 lean_object* l_Eq_ndrecOn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_unexpand____x40_Init_Core___hyg_1221____rarg(lean_object*);
+lean_object* l_myMacro____x40_Init_Core___hyg_1508____closed__5;
 lean_object* l_Quotient_rec___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 lean_object* l_term___x3c_x2d_x3e_____closed__1;
@@ -288,7 +291,6 @@ lean_object* l_term___u2248_____closed__6;
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 lean_object* l_Quotient_recOnSubsingleton_u2082(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Decidable_byCases(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__3;
 lean_object* l_inline___rarg(lean_object*);
 lean_object* l_instDecidableEqSum_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
@@ -1995,6 +1997,23 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_instInhabitedTask___rarg(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l_instInhabitedTask(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_instInhabitedTask___rarg), 1, 0);
+return x_2;
+}
+}
 lean_object* l_Task_pure___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -2197,7 +2216,7 @@ x_1 = l_term___x21_x3d_____closed__6;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1492____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1508____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -2205,22 +2224,22 @@ x_1 = lean_mk_string("bne");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1492____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1508____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Core___hyg_1492____closed__1;
+x_1 = l_myMacro____x40_Init_Core___hyg_1508____closed__1;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1492____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1508____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Core___hyg_1492____closed__1;
+x_1 = l_myMacro____x40_Init_Core___hyg_1508____closed__1;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Core___hyg_1492____closed__2;
+x_3 = l_myMacro____x40_Init_Core___hyg_1508____closed__2;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -2228,41 +2247,41 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1492____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1508____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Core___hyg_1492____closed__1;
+x_2 = l_myMacro____x40_Init_Core___hyg_1508____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1492____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1508____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Core___hyg_1492____closed__4;
+x_2 = l_myMacro____x40_Init_Core___hyg_1508____closed__4;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1492____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1508____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Core___hyg_1492____closed__5;
+x_2 = l_myMacro____x40_Init_Core___hyg_1508____closed__5;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_myMacro____x40_Init_Core___hyg_1492_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Core___hyg_1508_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -2299,10 +2318,10 @@ lean_inc(x_15);
 x_16 = lean_ctor_get(x_2, 1);
 lean_inc(x_16);
 lean_dec(x_2);
-x_17 = l_myMacro____x40_Init_Core___hyg_1492____closed__4;
+x_17 = l_myMacro____x40_Init_Core___hyg_1508____closed__4;
 x_18 = l_Lean_addMacroScope(x_16, x_17, x_15);
-x_19 = l_myMacro____x40_Init_Core___hyg_1492____closed__3;
-x_20 = l_myMacro____x40_Init_Core___hyg_1492____closed__6;
+x_19 = l_myMacro____x40_Init_Core___hyg_1508____closed__3;
+x_20 = l_myMacro____x40_Init_Core___hyg_1508____closed__6;
 x_21 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_21, 0, x_14);
 lean_ctor_set(x_21, 1, x_19);
@@ -2337,10 +2356,10 @@ lean_inc(x_33);
 x_34 = lean_ctor_get(x_2, 1);
 lean_inc(x_34);
 lean_dec(x_2);
-x_35 = l_myMacro____x40_Init_Core___hyg_1492____closed__4;
+x_35 = l_myMacro____x40_Init_Core___hyg_1508____closed__4;
 x_36 = l_Lean_addMacroScope(x_34, x_35, x_33);
-x_37 = l_myMacro____x40_Init_Core___hyg_1492____closed__3;
-x_38 = l_myMacro____x40_Init_Core___hyg_1492____closed__6;
+x_37 = l_myMacro____x40_Init_Core___hyg_1508____closed__3;
+x_38 = l_myMacro____x40_Init_Core___hyg_1508____closed__6;
 x_39 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_39, 0, x_31);
 lean_ctor_set(x_39, 1, x_37);
@@ -2367,7 +2386,7 @@ return x_49;
 }
 }
 }
-lean_object* l_unexpand____x40_Init_Core___hyg_1476_(lean_object* x_1, lean_object* x_2) {
+lean_object* l_unexpand____x40_Init_Core___hyg_1492_(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -2583,7 +2602,7 @@ x_1 = l_term___u2260_____closed__6;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1874____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1890____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -2591,22 +2610,22 @@ x_1 = lean_mk_string("Ne");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1874____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1890____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Core___hyg_1874____closed__1;
+x_1 = l_myMacro____x40_Init_Core___hyg_1890____closed__1;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1874____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1890____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Core___hyg_1874____closed__1;
+x_1 = l_myMacro____x40_Init_Core___hyg_1890____closed__1;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Core___hyg_1874____closed__2;
+x_3 = l_myMacro____x40_Init_Core___hyg_1890____closed__2;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -2614,41 +2633,41 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1874____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1890____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Core___hyg_1874____closed__1;
+x_2 = l_myMacro____x40_Init_Core___hyg_1890____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1874____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1890____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_2 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1874____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Core___hyg_1890____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Core___hyg_1874____closed__5;
+x_2 = l_myMacro____x40_Init_Core___hyg_1890____closed__5;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_myMacro____x40_Init_Core___hyg_1874_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Core___hyg_1890_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -2685,10 +2704,10 @@ lean_inc(x_15);
 x_16 = lean_ctor_get(x_2, 1);
 lean_inc(x_16);
 lean_dec(x_2);
-x_17 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_17 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_18 = l_Lean_addMacroScope(x_16, x_17, x_15);
-x_19 = l_myMacro____x40_Init_Core___hyg_1874____closed__3;
-x_20 = l_myMacro____x40_Init_Core___hyg_1874____closed__6;
+x_19 = l_myMacro____x40_Init_Core___hyg_1890____closed__3;
+x_20 = l_myMacro____x40_Init_Core___hyg_1890____closed__6;
 x_21 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_21, 0, x_14);
 lean_ctor_set(x_21, 1, x_19);
@@ -2723,10 +2742,10 @@ lean_inc(x_33);
 x_34 = lean_ctor_get(x_2, 1);
 lean_inc(x_34);
 lean_dec(x_2);
-x_35 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_35 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_36 = l_Lean_addMacroScope(x_34, x_35, x_33);
-x_37 = l_myMacro____x40_Init_Core___hyg_1874____closed__3;
-x_38 = l_myMacro____x40_Init_Core___hyg_1874____closed__6;
+x_37 = l_myMacro____x40_Init_Core___hyg_1890____closed__3;
+x_38 = l_myMacro____x40_Init_Core___hyg_1890____closed__6;
 x_39 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_39, 0, x_31);
 lean_ctor_set(x_39, 1, x_37);
@@ -2753,7 +2772,7 @@ return x_49;
 }
 }
 }
-lean_object* l_unexpand____x40_Init_Core___hyg_1858_(lean_object* x_1, lean_object* x_2) {
+lean_object* l_unexpand____x40_Init_Core___hyg_1874_(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -4482,18 +4501,18 @@ l_term___x21_x3d_____closed__6 = _init_l_term___x21_x3d_____closed__6();
 lean_mark_persistent(l_term___x21_x3d_____closed__6);
 l_term___x21_x3d__ = _init_l_term___x21_x3d__();
 lean_mark_persistent(l_term___x21_x3d__);
-l_myMacro____x40_Init_Core___hyg_1492____closed__1 = _init_l_myMacro____x40_Init_Core___hyg_1492____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1492____closed__1);
-l_myMacro____x40_Init_Core___hyg_1492____closed__2 = _init_l_myMacro____x40_Init_Core___hyg_1492____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1492____closed__2);
-l_myMacro____x40_Init_Core___hyg_1492____closed__3 = _init_l_myMacro____x40_Init_Core___hyg_1492____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1492____closed__3);
-l_myMacro____x40_Init_Core___hyg_1492____closed__4 = _init_l_myMacro____x40_Init_Core___hyg_1492____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1492____closed__4);
-l_myMacro____x40_Init_Core___hyg_1492____closed__5 = _init_l_myMacro____x40_Init_Core___hyg_1492____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1492____closed__5);
-l_myMacro____x40_Init_Core___hyg_1492____closed__6 = _init_l_myMacro____x40_Init_Core___hyg_1492____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1492____closed__6);
+l_myMacro____x40_Init_Core___hyg_1508____closed__1 = _init_l_myMacro____x40_Init_Core___hyg_1508____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1508____closed__1);
+l_myMacro____x40_Init_Core___hyg_1508____closed__2 = _init_l_myMacro____x40_Init_Core___hyg_1508____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1508____closed__2);
+l_myMacro____x40_Init_Core___hyg_1508____closed__3 = _init_l_myMacro____x40_Init_Core___hyg_1508____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1508____closed__3);
+l_myMacro____x40_Init_Core___hyg_1508____closed__4 = _init_l_myMacro____x40_Init_Core___hyg_1508____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1508____closed__4);
+l_myMacro____x40_Init_Core___hyg_1508____closed__5 = _init_l_myMacro____x40_Init_Core___hyg_1508____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1508____closed__5);
+l_myMacro____x40_Init_Core___hyg_1508____closed__6 = _init_l_myMacro____x40_Init_Core___hyg_1508____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1508____closed__6);
 l_term___u2260_____closed__1 = _init_l_term___u2260_____closed__1();
 lean_mark_persistent(l_term___u2260_____closed__1);
 l_term___u2260_____closed__2 = _init_l_term___u2260_____closed__2();
@@ -4508,18 +4527,18 @@ l_term___u2260_____closed__6 = _init_l_term___u2260_____closed__6();
 lean_mark_persistent(l_term___u2260_____closed__6);
 l_term___u2260__ = _init_l_term___u2260__();
 lean_mark_persistent(l_term___u2260__);
-l_myMacro____x40_Init_Core___hyg_1874____closed__1 = _init_l_myMacro____x40_Init_Core___hyg_1874____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1874____closed__1);
-l_myMacro____x40_Init_Core___hyg_1874____closed__2 = _init_l_myMacro____x40_Init_Core___hyg_1874____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1874____closed__2);
-l_myMacro____x40_Init_Core___hyg_1874____closed__3 = _init_l_myMacro____x40_Init_Core___hyg_1874____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1874____closed__3);
-l_myMacro____x40_Init_Core___hyg_1874____closed__4 = _init_l_myMacro____x40_Init_Core___hyg_1874____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1874____closed__4);
-l_myMacro____x40_Init_Core___hyg_1874____closed__5 = _init_l_myMacro____x40_Init_Core___hyg_1874____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1874____closed__5);
-l_myMacro____x40_Init_Core___hyg_1874____closed__6 = _init_l_myMacro____x40_Init_Core___hyg_1874____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1874____closed__6);
+l_myMacro____x40_Init_Core___hyg_1890____closed__1 = _init_l_myMacro____x40_Init_Core___hyg_1890____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1890____closed__1);
+l_myMacro____x40_Init_Core___hyg_1890____closed__2 = _init_l_myMacro____x40_Init_Core___hyg_1890____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1890____closed__2);
+l_myMacro____x40_Init_Core___hyg_1890____closed__3 = _init_l_myMacro____x40_Init_Core___hyg_1890____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1890____closed__3);
+l_myMacro____x40_Init_Core___hyg_1890____closed__4 = _init_l_myMacro____x40_Init_Core___hyg_1890____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1890____closed__4);
+l_myMacro____x40_Init_Core___hyg_1890____closed__5 = _init_l_myMacro____x40_Init_Core___hyg_1890____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1890____closed__5);
+l_myMacro____x40_Init_Core___hyg_1890____closed__6 = _init_l_myMacro____x40_Init_Core___hyg_1890____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Core___hyg_1890____closed__6);
 l_instDecidableTrue = _init_l_instDecidableTrue();
 l_instDecidableFalse = _init_l_instDecidableFalse();
 l_instInhabitedProp = _init_l_instInhabitedProp();
diff --git a/stage0/stdlib/Init/Data/Int/Basic.c b/stage0/stdlib/Init/Data/Int/Basic.c
index e59aa21b7f..c4adbba3db 100644
--- a/stage0/stdlib/Init/Data/Int/Basic.c
+++ b/stage0/stdlib/Init/Data/Int/Basic.c
@@ -22,7 +22,6 @@ lean_object* l_Int_sub___boxed(lean_object*, lean_object*);
 uint8_t l_Int_instDecidableEqInt(lean_object*, lean_object*);
 lean_object* l_Int_negSucc___boxed(lean_object*);
 lean_object* l_Int_instMulInt___closed__1;
-lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Int_decLt___boxed(lean_object*, lean_object*);
 lean_object* l_Int_decEq___boxed(lean_object*, lean_object*);
 lean_object* lean_int_mod(lean_object*, lean_object*);
@@ -52,6 +51,7 @@ lean_object* l_Int_instLTInt;
 lean_object* l_Int_instInhabitedInt;
 lean_object* l_Int_instModInt___closed__1;
 lean_object* l_Int_negOfNat___boxed(lean_object*);
+lean_object* l_Int_pow(lean_object*, lean_object*);
 lean_object* l_Int_negOfNat_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Int_instLEInt;
 lean_object* l_Int_natMod___boxed(lean_object*, lean_object*);
@@ -60,7 +60,6 @@ lean_object* l_Int_toNat_match__1___rarg(lean_object*, lean_object*, lean_object
 lean_object* lean_int_neg(lean_object*);
 lean_object* l_instCoeNatInt(lean_object*);
 lean_object* lean_int_neg_succ_of_nat(lean_object*);
-lean_object* l_Int_Int_pow___boxed(lean_object*, lean_object*);
 uint8_t lean_int_dec_le(lean_object*, lean_object*);
 lean_object* l_Int_toNat_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Int_negOfNat(lean_object*);
@@ -80,9 +79,10 @@ uint8_t lean_int_dec_eq(lean_object*, lean_object*);
 lean_object* l_Int_instHPowIntNatInt___closed__1;
 lean_object* l_Int_add___boxed(lean_object*, lean_object*);
 lean_object* l_Int_instMulInt;
-lean_object* l_Int_Int_pow(lean_object*, lean_object*);
 lean_object* l_Int_instAddInt;
 lean_object* lean_nat_to_int(lean_object*);
+lean_object* l_Int_pow___closed__1;
+lean_object* l_Int_pow___boxed(lean_object*, lean_object*);
 lean_object* l_Int_ofNat___boxed(lean_object* x_1) {
 _start:
 {
@@ -658,7 +658,7 @@ lean_dec(x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_Int_Int_pow___closed__1() {
+static lean_object* _init_l_Int_pow___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -667,7 +667,7 @@ x_2 = lean_nat_to_int(x_1);
 return x_2;
 }
 }
-lean_object* l_Int_Int_pow(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Int_pow(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -678,7 +678,7 @@ if (x_4 == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_2, x_5);
-x_7 = l_Int_Int_pow(x_1, x_6);
+x_7 = l_Int_pow(x_1, x_6);
 lean_dec(x_6);
 x_8 = lean_int_mul(x_7, x_1);
 lean_dec(x_7);
@@ -687,16 +687,16 @@ return x_8;
 else
 {
 lean_object* x_9; 
-x_9 = l_Int_Int_pow___closed__1;
+x_9 = l_Int_pow___closed__1;
 return x_9;
 }
 }
 }
-lean_object* l_Int_Int_pow___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Int_pow___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Int_Int_pow(x_1, x_2);
+x_3 = l_Int_pow(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -706,7 +706,7 @@ static lean_object* _init_l_Int_instHPowIntNatInt___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Int_Int_pow___boxed), 2, 0);
+x_1 = lean_alloc_closure((void*)(l_Int_pow___boxed), 2, 0);
 return x_1;
 }
 }
@@ -767,8 +767,8 @@ l_Int_instModInt___closed__1 = _init_l_Int_instModInt___closed__1();
 lean_mark_persistent(l_Int_instModInt___closed__1);
 l_Int_instModInt = _init_l_Int_instModInt();
 lean_mark_persistent(l_Int_instModInt);
-l_Int_Int_pow___closed__1 = _init_l_Int_Int_pow___closed__1();
-lean_mark_persistent(l_Int_Int_pow___closed__1);
+l_Int_pow___closed__1 = _init_l_Int_pow___closed__1();
+lean_mark_persistent(l_Int_pow___closed__1);
 l_Int_instHPowIntNatInt___closed__1 = _init_l_Int_instHPowIntNatInt___closed__1();
 lean_mark_persistent(l_Int_instHPowIntNatInt___closed__1);
 l_Int_instHPowIntNatInt = _init_l_Int_instHPowIntNatInt();
diff --git a/stage0/stdlib/Init/Data/List/Basic.c b/stage0/stdlib/Init/Data/List/Basic.c
index d6cce00817..de227f4711 100644
--- a/stage0/stdlib/Init/Data/List/Basic.c
+++ b/stage0/stdlib/Init/Data/List/Basic.c
@@ -48,6 +48,7 @@ lean_object* l_List_foldr___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_isEqv_match__1(lean_object*, lean_object*);
 lean_object* l_List_unzip___rarg(lean_object*);
 uint8_t l_List_notElem___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_List_minimum_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_rangeAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_reverseAux(lean_object*);
 lean_object* l_List_replace___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -60,6 +61,7 @@ lean_object* l_List_all___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
 uint8_t l_List_elem___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_join(lean_object*);
+lean_object* l_max___at_List_maximum_x3f___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_List_contains___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_find_x3f(lean_object*);
 lean_object* l_List_isEqv___rarg___boxed(lean_object*, lean_object*, lean_object*);
@@ -67,11 +69,13 @@ lean_object* l_List_groupByAux(lean_object*);
 lean_object* l_List_partition(lean_object*);
 lean_object* l_List_foldr___at_List_any___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t l_List_isEqv___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_List_foldl___at_List_minimum_x3f___spec__2(lean_object*);
 lean_object* l_List_range(lean_object*);
 lean_object* l_List_zipWith___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_filter___rarg(lean_object*, lean_object*);
 lean_object* l_List_foldr___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_dropWhile(lean_object*);
+lean_object* l_List_foldl___at_List_maximum_x3f___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_hasDecidableLt_match__6___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_groupBy___rarg(lean_object*, lean_object*);
 lean_object* l_List_hasDecidableLt_match__7___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -79,6 +83,7 @@ lean_object* l_List_iota_match__1___rarg(lean_object*, lean_object*, lean_object
 lean_object* l_List_iota_match__1(lean_object*);
 lean_object* l_List_eraseIdx_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_join___rarg(lean_object*);
+lean_object* l_max___at_List_maximum_x3f___spec__1(lean_object*, lean_object*);
 lean_object* l_List_instLEList(lean_object*, lean_object*);
 lean_object* l_List_pure___rarg(lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -95,6 +100,9 @@ lean_object* l_List_hasDecidableLt_match__4___boxed(lean_object*, lean_object*,
 lean_object* l_List_filterAux___at_List_removeAll___spec__1(lean_object*);
 lean_object* l_List_hasDecidableLt_match__6___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_List_reverse(lean_object*);
+lean_object* l_List_minimum_x3f___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_List_minimum_x3f(lean_object*);
+lean_object* l_List_foldl___at_List_minimum_x3f___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_groupByAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_List_enum(lean_object*);
@@ -125,12 +133,15 @@ lean_object* l_List_replicate(lean_object*);
 lean_object* l_List_append(lean_object*);
 lean_object* l_List_erase_match__1___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_List_enum___rarg(lean_object*);
+lean_object* l_min___at_List_minimum_x3f___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_min___at_List_minimum_x3f___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___rarg(lean_object*, lean_object*);
 lean_object* l_List_findSome_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_List_eraseIdx___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_List_groupByAux_match__1(lean_object*, lean_object*);
 lean_object* l_List_eraseDups(lean_object*);
 lean_object* l_List_hasDecidableLt_match__5___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_List_maximum_x3f(lean_object*);
 lean_object* l_List_drop_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_zipWith(lean_object*, lean_object*, lean_object*);
 uint8_t l_List_foldr___at_List_all___spec__1___rarg(lean_object*, uint8_t, lean_object*);
@@ -139,6 +150,7 @@ lean_object* l_List_erase_match__2___rarg(lean_object*, lean_object*, lean_objec
 lean_object* l_List_lookup(lean_object*, lean_object*);
 lean_object* l_List_beq_match__1(lean_object*, lean_object*);
 lean_object* l_List_eraseDupsAux(lean_object*);
+lean_object* l_min___at_List_minimum_x3f___spec__1(lean_object*, lean_object*);
 lean_object* l_List_unzip_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_List_hasDecidableLt(lean_object*);
 lean_object* l_List_eraseRepsAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -171,17 +183,21 @@ lean_object* l_List_drop___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_List_partition___rarg___closed__1;
 lean_object* l_List_instBEqList___rarg(lean_object*);
 lean_object* l_List_foldr___at_List_all___spec__1(lean_object*);
+lean_object* l_List_maximum_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_init(lean_object*);
 lean_object* l_List_find_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_List_removeAll___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_max___at_List_maximum_x3f___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_isSuffixOf___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldr___at_List_or___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_List_partitionAux___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_eraseIdx___rarg(lean_object*, lean_object*);
 lean_object* l_List_dropWhile___rarg(lean_object*, lean_object*);
+lean_object* l_List_maximum_x3f___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_unzip_match__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_rangeAux_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_List_and(lean_object*);
+lean_object* l_List_foldl___at_List_maximum_x3f___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_eraseIdx_match__1(lean_object*, lean_object*);
 lean_object* l_List_intersperse___rarg(lean_object*, lean_object*);
 lean_object* l_List_eraseRepsAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -208,6 +224,7 @@ lean_object* l_List_filterAux(lean_object*);
 lean_object* l_List_filterMap_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldr(lean_object*, lean_object*);
 lean_object* l_List_enumFrom(lean_object*);
+lean_object* l_List_foldl___at_List_minimum_x3f___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_rangeAux(lean_object*, lean_object*);
 lean_object* l_List_foldr___at_List_all___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_take___rarg(lean_object*, lean_object*);
@@ -220,6 +237,7 @@ lean_object* l_List_groupBy(lean_object*);
 lean_object* l_List_instAppendList___closed__1;
 lean_object* l_List_reverseAux___rarg(lean_object*, lean_object*);
 lean_object* l_List_isPrefixOf_match__1(lean_object*, lean_object*);
+lean_object* l_List_foldl___at_List_maximum_x3f___spec__2(lean_object*);
 lean_object* l_List_instListDecidableLe___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_List_any___rarg(lean_object*, lean_object*);
 lean_object* l_List_hasDecidableLt_match__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -5244,6 +5262,248 @@ x_2 = lean_alloc_closure((void*)(l_List_dropLast___rarg), 1, 0);
 return x_2;
 }
 }
+lean_object* l_max___at_List_maximum_x3f___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; 
+lean_inc(x_2);
+lean_inc(x_3);
+x_4 = lean_apply_2(x_1, x_3, x_2);
+x_5 = lean_unbox(x_4);
+lean_dec(x_4);
+if (x_5 == 0)
+{
+lean_dec(x_2);
+return x_3;
+}
+else
+{
+lean_dec(x_3);
+return x_2;
+}
+}
+}
+lean_object* l_max___at_List_maximum_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_max___at_List_maximum_x3f___spec__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_List_foldl___at_List_maximum_x3f___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_4) == 0)
+{
+lean_dec(x_2);
+return x_3;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_4, 1);
+lean_inc(x_6);
+lean_dec(x_4);
+lean_inc(x_2);
+x_7 = l_max___at_List_maximum_x3f___spec__1___rarg(x_2, x_3, x_5);
+x_3 = x_7;
+x_4 = x_6;
+goto _start;
+}
+}
+}
+lean_object* l_List_foldl___at_List_maximum_x3f___spec__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_List_foldl___at_List_maximum_x3f___spec__2___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l_List_maximum_x3f___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_3) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_3, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_3, 1);
+lean_inc(x_6);
+lean_dec(x_3);
+x_7 = l_List_foldl___at_List_maximum_x3f___spec__2___rarg(x_1, x_2, x_5, x_6);
+x_8 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_8, 0, x_7);
+return x_8;
+}
+}
+}
+lean_object* l_List_maximum_x3f(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_List_maximum_x3f___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_max___at_List_maximum_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_max___at_List_maximum_x3f___spec__1(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+lean_object* l_List_foldl___at_List_maximum_x3f___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_List_foldl___at_List_maximum_x3f___spec__2___rarg(x_1, x_2, x_3, x_4);
+lean_dec(x_1);
+return x_5;
+}
+}
+lean_object* l_List_maximum_x3f___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_List_maximum_x3f___rarg(x_1, x_2, x_3);
+lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_min___at_List_minimum_x3f___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; 
+lean_inc(x_3);
+lean_inc(x_2);
+x_4 = lean_apply_2(x_1, x_2, x_3);
+x_5 = lean_unbox(x_4);
+lean_dec(x_4);
+if (x_5 == 0)
+{
+lean_dec(x_2);
+return x_3;
+}
+else
+{
+lean_dec(x_3);
+return x_2;
+}
+}
+}
+lean_object* l_min___at_List_minimum_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_min___at_List_minimum_x3f___spec__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_List_foldl___at_List_minimum_x3f___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_4) == 0)
+{
+lean_dec(x_2);
+return x_3;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_4, 1);
+lean_inc(x_6);
+lean_dec(x_4);
+lean_inc(x_2);
+x_7 = l_min___at_List_minimum_x3f___spec__1___rarg(x_2, x_3, x_5);
+x_3 = x_7;
+x_4 = x_6;
+goto _start;
+}
+}
+}
+lean_object* l_List_foldl___at_List_minimum_x3f___spec__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_List_foldl___at_List_minimum_x3f___spec__2___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l_List_minimum_x3f___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_3) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_3, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_3, 1);
+lean_inc(x_6);
+lean_dec(x_3);
+x_7 = l_List_foldl___at_List_minimum_x3f___spec__2___rarg(x_1, x_2, x_5, x_6);
+x_8 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_8, 0, x_7);
+return x_8;
+}
+}
+}
+lean_object* l_List_minimum_x3f(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_List_minimum_x3f___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_min___at_List_minimum_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_min___at_List_minimum_x3f___spec__1(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+lean_object* l_List_foldl___at_List_minimum_x3f___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_List_foldl___at_List_minimum_x3f___spec__2___rarg(x_1, x_2, x_3, x_4);
+lean_dec(x_1);
+return x_5;
+}
+}
+lean_object* l_List_minimum_x3f___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_List_minimum_x3f___rarg(x_1, x_2, x_3);
+lean_dec(x_1);
+return x_4;
+}
+}
 lean_object* initialize_Init_SimpLemmas(lean_object*);
 lean_object* initialize_Init_Data_Nat_Basic(lean_object*);
 static bool _G_initialized = false;
diff --git a/stage0/stdlib/Init/Data/Ord.c b/stage0/stdlib/Init/Data/Ord.c
index 2c9cc37c48..981d408648 100644
--- a/stage0/stdlib/Init/Data/Ord.c
+++ b/stage0/stdlib/Init/Data/Ord.c
@@ -13,44 +13,70 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+uint8_t l_Ordering_isLE(uint8_t);
 lean_object* l___private_Init_Data_Ord_0__beqOrdering____x40_Init_Data_Ord___hyg_10__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_instOrdBool(uint8_t, uint8_t);
+lean_object* l_instOrdUInt8___boxed(lean_object*, lean_object*);
 lean_object* l_instOrdUSize___boxed(lean_object*, lean_object*);
+uint8_t l_UInt64_decEq(uint64_t, uint64_t);
+lean_object* l_Ordering_isLE_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*);
+uint8_t l_UInt8_decEq(uint8_t, uint8_t);
 uint8_t l_USize_decEq(size_t, size_t);
+lean_object* l_instDecidableRelLtLtOfOrd___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_instBEqOrdering___closed__1;
 lean_object* l_instOrdFin___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_instOrdFin___boxed(lean_object*);
+lean_object* l_instOrdUInt64___boxed(lean_object*, lean_object*);
 lean_object* l_instOrdNat___boxed(lean_object*, lean_object*);
 lean_object* l_instBEqOrdering;
+uint8_t l_instDecidableRelLeLeOfOrd___rarg(lean_object*, lean_object*, lean_object*);
+uint8_t l_instOrdUInt8(uint8_t, uint8_t);
 uint8_t l_USize_decLt(size_t, size_t);
+uint8_t l_instOrdUInt64(uint64_t, uint64_t);
 lean_object* l_instOrdFin(lean_object*);
-uint8_t l_USize_cmp(size_t, size_t);
+lean_object* l_instDecidableRelLeLeOfOrd___rarg___boxed(lean_object*, lean_object*, lean_object*);
+uint8_t l_UInt8_decLt(uint8_t, uint8_t);
+lean_object* l_ltOfOrd___boxed(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_instOrdBool_match__1(lean_object*);
 uint8_t l_UInt32_decLt(uint32_t, uint32_t);
 uint8_t l___private_Init_Data_Ord_0__beqOrdering____x40_Init_Data_Ord___hyg_10_(uint8_t, uint8_t);
 uint8_t l_instInhabitedOrdering;
+uint8_t l_instOrdUInt16(uint16_t, uint16_t);
+uint8_t l_UInt64_decLt(uint64_t, uint64_t);
 lean_object* l_instOrdBool_match__1___rarg(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Ord_0__beqOrdering____x40_Init_Data_Ord___hyg_10____boxed(lean_object*, lean_object*);
+lean_object* l_instOrdUInt32___boxed(lean_object*, lean_object*);
+lean_object* l_leOfOrd(lean_object*, lean_object*);
+lean_object* l_instOrdUInt16___boxed(lean_object*, lean_object*);
 uint8_t l_instOrdInt(lean_object*, lean_object*);
+lean_object* l_Ordering_isLE_match__1(lean_object*);
 uint8_t l_instOrdFin___rarg(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Ord_0__beqOrdering____x40_Init_Data_Ord___hyg_10__match__1___rarg(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_instOrdNat(lean_object*, lean_object*);
+lean_object* l_ltOfOrd(lean_object*, lean_object*);
+lean_object* l_instDecidableRelLtLtOfOrd(lean_object*);
+lean_object* l_Ordering_isLE___boxed(lean_object*);
+lean_object* l_leOfOrd___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Ord_0__beqOrdering____x40_Init_Data_Ord___hyg_10__match__1(lean_object*);
 lean_object* l_instOrdString___boxed(lean_object*, lean_object*);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
+lean_object* l_Ordering_isLE_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instOrdBool___boxed(lean_object*, lean_object*);
 uint8_t l_compareOfLessAndEq___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
+uint8_t l_instOrdUInt32(uint32_t, uint32_t);
 uint8_t lean_int_dec_lt(lean_object*, lean_object*);
+uint8_t l_UInt16_decLt(uint16_t, uint16_t);
 uint8_t l_instOrdUSize(size_t, size_t);
 lean_object* l_instOrdInt___boxed(lean_object*, lean_object*);
+uint8_t l_UInt16_decEq(uint16_t, uint16_t);
 uint8_t l_instOrdString(lean_object*, lean_object*);
 lean_object* l_instOrdChar___boxed(lean_object*, lean_object*);
-lean_object* lean_usize_to_nat(size_t);
+lean_object* l_instDecidableRelLeLeOfOrd(lean_object*);
 uint8_t lean_int_dec_eq(lean_object*, lean_object*);
+uint8_t l_instDecidableRelLtLtOfOrd___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_instOrdBool_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_instOrdChar(uint32_t, uint32_t);
-lean_object* l_USize_cmp___boxed(lean_object*, lean_object*);
 lean_object* l_compareOfLessAndEq(lean_object*);
 lean_object* l_compareOfLessAndEq___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_dec_lt(lean_object*, lean_object*);
@@ -605,51 +631,174 @@ lean_dec(x_1);
 return x_2;
 }
 }
-uint8_t l_USize_cmp(size_t x_1, size_t x_2) {
+uint8_t l_instOrdUInt8(uint8_t x_1, uint8_t x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; uint8_t x_5; 
-x_3 = lean_usize_to_nat(x_1);
-x_4 = lean_usize_to_nat(x_2);
-x_5 = lean_nat_dec_lt(x_3, x_4);
-if (x_5 == 0)
+uint8_t x_3; 
+x_3 = x_1 < x_2;
+if (x_3 == 0)
+{
+uint8_t x_4; 
+x_4 = x_1 == x_2;
+if (x_4 == 0)
+{
+uint8_t x_5; 
+x_5 = 2;
+return x_5;
+}
+else
 {
 uint8_t x_6; 
-x_6 = lean_nat_dec_eq(x_3, x_4);
-lean_dec(x_4);
-lean_dec(x_3);
-if (x_6 == 0)
+x_6 = 1;
+return x_6;
+}
+}
+else
 {
 uint8_t x_7; 
-x_7 = 2;
+x_7 = 0;
 return x_7;
 }
-else
-{
-uint8_t x_8; 
-x_8 = 1;
-return x_8;
 }
 }
-else
-{
-uint8_t x_9; 
-lean_dec(x_4);
-lean_dec(x_3);
-x_9 = 0;
-return x_9;
-}
-}
-}
-lean_object* l_USize_cmp___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_instOrdUInt8___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_3; size_t x_4; uint8_t x_5; lean_object* x_6; 
-x_3 = lean_unbox_usize(x_1);
+uint8_t x_3; uint8_t x_4; uint8_t x_5; lean_object* x_6; 
+x_3 = lean_unbox(x_1);
 lean_dec(x_1);
-x_4 = lean_unbox_usize(x_2);
+x_4 = lean_unbox(x_2);
 lean_dec(x_2);
-x_5 = l_USize_cmp(x_3, x_4);
+x_5 = l_instOrdUInt8(x_3, x_4);
+x_6 = lean_box(x_5);
+return x_6;
+}
+}
+uint8_t l_instOrdUInt16(uint16_t x_1, uint16_t x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = x_1 < x_2;
+if (x_3 == 0)
+{
+uint8_t x_4; 
+x_4 = x_1 == x_2;
+if (x_4 == 0)
+{
+uint8_t x_5; 
+x_5 = 2;
+return x_5;
+}
+else
+{
+uint8_t x_6; 
+x_6 = 1;
+return x_6;
+}
+}
+else
+{
+uint8_t x_7; 
+x_7 = 0;
+return x_7;
+}
+}
+}
+lean_object* l_instOrdUInt16___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint16_t x_3; uint16_t x_4; uint8_t x_5; lean_object* x_6; 
+x_3 = lean_unbox(x_1);
+lean_dec(x_1);
+x_4 = lean_unbox(x_2);
+lean_dec(x_2);
+x_5 = l_instOrdUInt16(x_3, x_4);
+x_6 = lean_box(x_5);
+return x_6;
+}
+}
+uint8_t l_instOrdUInt32(uint32_t x_1, uint32_t x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = x_1 < x_2;
+if (x_3 == 0)
+{
+uint8_t x_4; 
+x_4 = x_1 == x_2;
+if (x_4 == 0)
+{
+uint8_t x_5; 
+x_5 = 2;
+return x_5;
+}
+else
+{
+uint8_t x_6; 
+x_6 = 1;
+return x_6;
+}
+}
+else
+{
+uint8_t x_7; 
+x_7 = 0;
+return x_7;
+}
+}
+}
+lean_object* l_instOrdUInt32___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint32_t x_3; uint32_t x_4; uint8_t x_5; lean_object* x_6; 
+x_3 = lean_unbox_uint32(x_1);
+lean_dec(x_1);
+x_4 = lean_unbox_uint32(x_2);
+lean_dec(x_2);
+x_5 = l_instOrdUInt32(x_3, x_4);
+x_6 = lean_box(x_5);
+return x_6;
+}
+}
+uint8_t l_instOrdUInt64(uint64_t x_1, uint64_t x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = x_1 < x_2;
+if (x_3 == 0)
+{
+uint8_t x_4; 
+x_4 = x_1 == x_2;
+if (x_4 == 0)
+{
+uint8_t x_5; 
+x_5 = 2;
+return x_5;
+}
+else
+{
+uint8_t x_6; 
+x_6 = 1;
+return x_6;
+}
+}
+else
+{
+uint8_t x_7; 
+x_7 = 0;
+return x_7;
+}
+}
+}
+lean_object* l_instOrdUInt64___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint64_t x_3; uint64_t x_4; uint8_t x_5; lean_object* x_6; 
+x_3 = lean_unbox_uint64(x_1);
+lean_dec(x_1);
+x_4 = lean_unbox_uint64(x_2);
+lean_dec(x_2);
+x_5 = l_instOrdUInt64(x_3, x_4);
 x_6 = lean_box(x_5);
 return x_6;
 }
@@ -740,6 +889,180 @@ x_6 = lean_box(x_5);
 return x_6;
 }
 }
+lean_object* l_ltOfOrd(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
+}
+}
+lean_object* l_ltOfOrd___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_ltOfOrd(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+uint8_t l_instDecidableRelLtLtOfOrd___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; uint8_t x_6; uint8_t x_7; 
+x_4 = lean_apply_2(x_1, x_2, x_3);
+x_5 = lean_unbox(x_4);
+lean_dec(x_4);
+x_6 = 0;
+x_7 = l___private_Init_Data_Ord_0__beqOrdering____x40_Init_Data_Ord___hyg_10_(x_5, x_6);
+return x_7;
+}
+}
+lean_object* l_instDecidableRelLtLtOfOrd(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_instDecidableRelLtLtOfOrd___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_instDecidableRelLtLtOfOrd___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_instDecidableRelLtLtOfOrd___rarg(x_1, x_2, x_3);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+lean_object* l_Ordering_isLE_match__1___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (x_1) {
+case 0:
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_7 = lean_box(0);
+x_8 = lean_apply_1(x_3, x_7);
+return x_8;
+}
+default: 
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_9 = lean_box(0);
+x_10 = lean_apply_1(x_4, x_9);
+return x_10;
+}
+}
+}
+}
+lean_object* l_Ordering_isLE_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Ordering_isLE_match__1___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Ordering_isLE_match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; lean_object* x_6; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = l_Ordering_isLE_match__1___rarg(x_5, x_2, x_3, x_4);
+return x_6;
+}
+}
+uint8_t l_Ordering_isLE(uint8_t x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_box(x_1);
+if (lean_obj_tag(x_2) == 2)
+{
+uint8_t x_3; 
+x_3 = 0;
+return x_3;
+}
+else
+{
+uint8_t x_4; 
+lean_dec(x_2);
+x_4 = 1;
+return x_4;
+}
+}
+}
+lean_object* l_Ordering_isLE___boxed(lean_object* x_1) {
+_start:
+{
+uint8_t x_2; uint8_t x_3; lean_object* x_4; 
+x_2 = lean_unbox(x_1);
+lean_dec(x_1);
+x_3 = l_Ordering_isLE(x_2);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+lean_object* l_leOfOrd(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
+}
+}
+lean_object* l_leOfOrd___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_leOfOrd(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+uint8_t l_instDecidableRelLeLeOfOrd___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; uint8_t x_6; 
+x_4 = lean_apply_2(x_1, x_2, x_3);
+x_5 = lean_unbox(x_4);
+lean_dec(x_4);
+x_6 = l_Ordering_isLE(x_5);
+return x_6;
+}
+}
+lean_object* l_instDecidableRelLeLeOfOrd(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_instDecidableRelLeLeOfOrd___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_instDecidableRelLeLeOfOrd___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_instDecidableRelLeLeOfOrd___rarg(x_1, x_2, x_3);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
 lean_object* initialize_Init_Data_Int(lean_object*);
 lean_object* initialize_Init_Data_String(lean_object*);
 static bool _G_initialized = false;
diff --git a/stage0/stdlib/Init/Data/Random.c b/stage0/stdlib/Init/Data/Random.c
index b0bf514d48..8230d35dab 100644
--- a/stage0/stdlib/Init/Data/Random.c
+++ b/stage0/stdlib/Init/Data/Random.c
@@ -30,7 +30,6 @@ lean_object* l_stdNext(lean_object*);
 lean_object* l_stdNext___closed__3;
 lean_object* l_IO_rand___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_instRandomGenStdGen___lambda__1___boxed(lean_object*);
 lean_object* l_instRandomGenStdGen___closed__3;
 lean_object* lean_int_mod(lean_object*, lean_object*);
@@ -95,6 +94,7 @@ lean_object* l___private_Init_Data_Random_0__randNatAux___at_IO_rand___spec__2__
 lean_object* l___private_Init_Data_Random_0__randNatAux___at_IO_rand___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instReprStdGen_match__1(lean_object*);
 lean_object* l_instInhabitedStdGen___closed__1;
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_mkStdGen(lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_randNat_match__1___rarg(lean_object*, lean_object*);
@@ -384,7 +384,7 @@ if (x_27 == 0)
 lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; 
 x_30 = lean_int_sub(x_28, x_26);
 lean_dec(x_28);
-x_31 = l_Int_Int_pow___closed__1;
+x_31 = l_Int_pow___closed__1;
 x_32 = lean_int_dec_lt(x_30, x_31);
 x_33 = l_Int_toNat(x_26);
 lean_dec(x_26);
@@ -430,7 +430,7 @@ x_44 = lean_int_add(x_26, x_43);
 lean_dec(x_26);
 x_45 = lean_int_sub(x_28, x_44);
 lean_dec(x_28);
-x_46 = l_Int_Int_pow___closed__1;
+x_46 = l_Int_pow___closed__1;
 x_47 = lean_int_dec_lt(x_45, x_46);
 x_48 = l_Int_toNat(x_44);
 lean_dec(x_44);
diff --git a/stage0/stdlib/Init/Data/Repr.c b/stage0/stdlib/Init/Data/Repr.c
index fb83ce3ffb..b7366a8a91 100644
--- a/stage0/stdlib/Init/Data/Repr.c
+++ b/stage0/stdlib/Init/Data/Repr.c
@@ -90,7 +90,6 @@ lean_object* l_instReprBool_match__1___rarg(uint8_t, lean_object*, lean_object*,
 lean_object* l_instReprAtomUInt16;
 lean_object* l_Char_quoteCore___closed__1;
 lean_object* l_Char_quoteCore___boxed(lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_instReprOption___rarg___closed__3;
 lean_object* l_instReprDecidable_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_reprStr___rarg(lean_object*, lean_object*);
@@ -255,6 +254,7 @@ lean_object* l_instReprBool_match__1(lean_object*);
 lean_object* l_charToHex___boxed(lean_object*);
 extern lean_object* l_Std_Format_paren___closed__3;
 lean_object* l_instReprSigma___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 extern lean_object* l___private_Init_Data_Format_Basic_0__Std_Format_be___closed__1;
 lean_object* lean_uint8_to_nat(uint8_t);
 lean_object* l_instReprProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3143,7 +3143,7 @@ static lean_object* _init_l___private_Init_Data_Repr_0__reprSourceInfo____x40_In
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Init_Data_Repr_0__reprSourceInfo____x40_Init_Data_Repr___hyg_1438____closed__9;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -3316,7 +3316,7 @@ lean_ctor_set(x_64, 1, x_52);
 x_65 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_65, 0, x_64);
 lean_ctor_set(x_65, 1, x_12);
-x_66 = l_Int_Int_pow___closed__1;
+x_66 = l_Int_pow___closed__1;
 x_67 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_67, 0, x_66);
 lean_ctor_set(x_67, 1, x_65);
@@ -3372,7 +3372,7 @@ return x_88;
 else
 {
 lean_object* x_89; lean_object* x_90; uint8_t x_91; lean_object* x_92; lean_object* x_93; 
-x_89 = l_Int_Int_pow___closed__1;
+x_89 = l_Int_pow___closed__1;
 x_90 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_90, 0, x_89);
 lean_ctor_set(x_90, 1, x_83);
diff --git a/stage0/stdlib/Init/Data/String/Basic.c b/stage0/stdlib/Init/Data/String/Basic.c
index 84f1c1baca..f58c5a15d9 100644
--- a/stage0/stdlib/Init/Data/String/Basic.c
+++ b/stage0/stdlib/Init/Data/String/Basic.c
@@ -40,6 +40,7 @@ lean_object* l_String_length___boxed(lean_object*);
 lean_object* l_String_Iterator_remainingBytes___boxed(lean_object*);
 lean_object* l_Substring_extract___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_String_Basic_0__Substring_takeRightWhileAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_String_findAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Substring_extract_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_anyAux_loop___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_trimRight___boxed(lean_object*);
@@ -55,6 +56,7 @@ lean_object* l_String_toUpper(lean_object*);
 lean_object* l_List_foldl___at_String_join___spec__1(lean_object*, lean_object*);
 lean_object* l_String_push_match__1(lean_object*);
 lean_object* l_Substring_toNat_x3f(lean_object*);
+lean_object* l_String_find(lean_object*, lean_object*);
 uint8_t l_String_anyAux_loop(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_revPosOf(lean_object*, uint32_t);
 lean_object* l_Substring_toString___boxed(lean_object*);
@@ -104,6 +106,7 @@ lean_object* l_String_dropWhile(lean_object*, lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_String_trimLeft___boxed(lean_object*);
 lean_object* l_String_Iterator_forward_match__1(lean_object*);
+lean_object* l_String_revFind___boxed(lean_object*, lean_object*);
 lean_object* l_String_set_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_toNat_x3f___lambda__1(lean_object*, uint32_t);
 lean_object* l___private_Init_Data_String_Basic_0__Substring_nextn(lean_object*, lean_object*, lean_object*);
@@ -128,6 +131,7 @@ lean_object* l_String_isNat___boxed(lean_object*);
 lean_object* l_String_instAppendString;
 lean_object* l_Substring_dropWhile(lean_object*, lean_object*);
 lean_object* l_String_isNat___closed__1;
+lean_object* l_String_find___boxed(lean_object*, lean_object*);
 lean_object* l_Substring_all___boxed(lean_object*, lean_object*);
 lean_object* l_String_takeWhile(lean_object*, lean_object*);
 lean_object* l_String_push_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
@@ -141,6 +145,7 @@ lean_object* l_String_Iterator_forward(lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 uint32_t l_String_getOp(lean_object*, lean_object*);
 lean_object* l_String_foldl___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_String_findAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Substring_get_match__1(lean_object*);
 lean_object* l_Substring_takeRight(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_String_Basic_0__String_utf8SetAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -162,6 +167,8 @@ lean_object* l_String_isNat___lambda__1___boxed(lean_object*);
 lean_object* l_String_join(lean_object*);
 lean_object* l_String_revPosOfAux(lean_object*, uint32_t, lean_object*);
 lean_object* l_String_Iterator_nextn(lean_object*, lean_object*);
+lean_object* l_String_revFindAux___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_String_revFindAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_String_Iterator_isPrefixOfRemaining___boxed(lean_object*, lean_object*);
 lean_object* l_Substring_takeWhile(lean_object*, lean_object*);
 lean_object* l_String_singleton(uint32_t);
@@ -179,6 +186,7 @@ lean_object* l_Substring_any___boxed(lean_object*, lean_object*);
 lean_object* l_String_takeRight(lean_object*, lean_object*);
 lean_object* l_String_Iterator_setCurr_match__1(lean_object*);
 lean_object* l_String_getOp___boxed(lean_object*, lean_object*);
+uint8_t l_String_endsWith(lean_object*, lean_object*);
 lean_object* l_Substring_toIterator(lean_object*);
 lean_object* l_Substring_hasBeq;
 lean_object* l___private_Init_Data_String_Basic_0__Substring_prevn___boxed(lean_object*, lean_object*, lean_object*);
@@ -191,11 +199,13 @@ lean_object* l_String_Iterator_remainingToString___boxed(lean_object*);
 lean_object* l_Substring_trimRight(lean_object*);
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 lean_object* l_String_splitOnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_String_revFind(lean_object*, lean_object*);
 lean_object* l_String_splitOn___boxed(lean_object*, lean_object*);
 lean_object* l_String_Iterator_prevn(lean_object*, lean_object*);
 lean_object* l_String_foldl(lean_object*);
 lean_object* l_String_foldr___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Substring_beq(lean_object*, lean_object*);
+lean_object* l_String_endsWith___boxed(lean_object*, lean_object*);
 lean_object* l_Substring_toString_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_String_extract_match__1(lean_object*);
 lean_object* l_String_Iterator_next(lean_object*);
@@ -267,6 +277,7 @@ uint8_t l_String_anyAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_String_Basic_0__Substring_nextn_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_toLower(lean_object*);
 lean_object* l_String_foldlAux(lean_object*);
+uint8_t l_String_startsWith(lean_object*, lean_object*);
 lean_object* l_String_toNat_x3f___boxed(lean_object*);
 lean_object* l_String_foldrAux_loop___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_posOf___boxed(lean_object*, lean_object*);
@@ -304,6 +315,7 @@ lean_object* l_String_foldrAux___rarg(lean_object*, lean_object*, lean_object*,
 lean_object* l_String_set_match__1___rarg(lean_object*, lean_object*, uint32_t, lean_object*);
 lean_object* l_String_push___boxed(lean_object*, lean_object*);
 lean_object* l_String_drop(lean_object*, lean_object*);
+lean_object* l_String_startsWith___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_String_Basic_0__String_utf8GetAux___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_String_pushn(lean_object*, uint32_t, lean_object*);
 lean_object* l_Substring_drop_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -1026,6 +1038,156 @@ lean_dec(x_1);
 return x_4;
 }
 }
+lean_object* l_String_findAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; 
+x_5 = lean_nat_dec_eq(x_4, x_3);
+if (x_5 == 0)
+{
+uint32_t x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_6 = lean_string_utf8_get(x_1, x_4);
+x_7 = lean_box_uint32(x_6);
+lean_inc(x_2);
+x_8 = lean_apply_1(x_2, x_7);
+x_9 = lean_unbox(x_8);
+lean_dec(x_8);
+if (x_9 == 0)
+{
+lean_object* x_10; 
+x_10 = lean_string_utf8_next(x_1, x_4);
+lean_dec(x_4);
+x_4 = x_10;
+goto _start;
+}
+else
+{
+lean_dec(x_2);
+return x_4;
+}
+}
+else
+{
+lean_dec(x_2);
+return x_4;
+}
+}
+}
+lean_object* l_String_findAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_String_findAux(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_5;
+}
+}
+lean_object* l_String_find(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_string_utf8_byte_size(x_1);
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = l_String_findAux(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
+lean_object* l_String_find___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_String_find(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_String_revFindAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint32_t x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_4 = lean_string_utf8_get(x_1, x_3);
+x_5 = lean_box_uint32(x_4);
+lean_inc(x_2);
+x_6 = lean_apply_1(x_2, x_5);
+x_7 = lean_unbox(x_6);
+lean_dec(x_6);
+if (x_7 == 0)
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_unsigned_to_nat(0u);
+x_9 = lean_nat_dec_eq(x_3, x_8);
+if (x_9 == 0)
+{
+lean_object* x_10; 
+x_10 = lean_string_utf8_prev(x_1, x_3);
+lean_dec(x_3);
+x_3 = x_10;
+goto _start;
+}
+else
+{
+lean_object* x_12; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_box(0);
+return x_12;
+}
+}
+else
+{
+lean_object* x_13; 
+lean_dec(x_2);
+x_13 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_13, 0, x_3);
+return x_13;
+}
+}
+}
+lean_object* l_String_revFindAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_String_revFindAux(x_1, x_2, x_3);
+lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_String_revFind(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; uint8_t x_5; 
+x_3 = lean_string_utf8_byte_size(x_1);
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = lean_nat_dec_eq(x_3, x_4);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; 
+x_6 = lean_string_utf8_prev(x_1, x_3);
+lean_dec(x_3);
+x_7 = l_String_revFindAux(x_1, x_2, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_8 = lean_box(0);
+return x_8;
+}
+}
+}
+lean_object* l_String_revFind___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_String_revFind(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
 lean_object* l___private_Init_Data_String_Basic_0__String_utf8ExtractAux_u2082(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -4639,15 +4801,30 @@ lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_obj
 x_3 = lean_ctor_get(x_1, 0);
 x_4 = lean_ctor_get(x_1, 1);
 x_5 = lean_ctor_get(x_1, 2);
-x_6 = lean_string_utf8_extract(x_3, x_4, x_5);
+x_6 = lean_nat_sub(x_5, x_4);
 x_7 = lean_ctor_get(x_2, 0);
 x_8 = lean_ctor_get(x_2, 1);
 x_9 = lean_ctor_get(x_2, 2);
-x_10 = lean_string_utf8_extract(x_7, x_8, x_9);
-x_11 = lean_string_dec_eq(x_6, x_10);
+x_10 = lean_nat_sub(x_9, x_8);
+x_11 = lean_nat_dec_eq(x_6, x_10);
 lean_dec(x_10);
 lean_dec(x_6);
-return x_11;
+if (x_11 == 0)
+{
+uint8_t x_12; 
+x_12 = 0;
+return x_12;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_13 = lean_string_utf8_extract(x_3, x_4, x_5);
+x_14 = lean_string_utf8_extract(x_7, x_8, x_9);
+x_15 = lean_string_dec_eq(x_13, x_14);
+lean_dec(x_14);
+lean_dec(x_13);
+return x_15;
+}
 }
 }
 lean_object* l_Substring_beq___boxed(lean_object* x_1, lean_object* x_2) {
@@ -4857,6 +5034,88 @@ lean_dec(x_1);
 return x_3;
 }
 }
+uint8_t l_String_startsWith(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_3 = lean_string_utf8_byte_size(x_1);
+x_4 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_5 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_5, 0, x_1);
+lean_ctor_set(x_5, 1, x_4);
+lean_ctor_set(x_5, 2, x_3);
+x_6 = lean_string_length(x_2);
+x_7 = l___private_Init_Data_String_Basic_0__Substring_nextn(x_5, x_6, x_4);
+lean_dec(x_5);
+x_8 = lean_nat_add(x_4, x_7);
+lean_dec(x_7);
+x_9 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_9, 0, x_1);
+lean_ctor_set(x_9, 1, x_4);
+lean_ctor_set(x_9, 2, x_8);
+x_10 = lean_string_utf8_byte_size(x_2);
+x_11 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_11, 0, x_2);
+lean_ctor_set(x_11, 1, x_4);
+lean_ctor_set(x_11, 2, x_10);
+x_12 = l_Substring_beq(x_9, x_11);
+lean_dec(x_11);
+lean_dec(x_9);
+return x_12;
+}
+}
+lean_object* l_String_startsWith___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_String_startsWith(x_1, x_2);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+uint8_t l_String_endsWith(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_3 = lean_string_utf8_byte_size(x_1);
+x_4 = lean_unsigned_to_nat(0u);
+lean_inc(x_3);
+lean_inc(x_1);
+x_5 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_5, 0, x_1);
+lean_ctor_set(x_5, 1, x_4);
+lean_ctor_set(x_5, 2, x_3);
+x_6 = lean_string_length(x_2);
+x_7 = lean_nat_sub(x_3, x_4);
+x_8 = l___private_Init_Data_String_Basic_0__Substring_prevn(x_5, x_6, x_7);
+lean_dec(x_5);
+x_9 = lean_nat_add(x_4, x_8);
+lean_dec(x_8);
+x_10 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_10, 0, x_1);
+lean_ctor_set(x_10, 1, x_9);
+lean_ctor_set(x_10, 2, x_3);
+x_11 = lean_string_utf8_byte_size(x_2);
+x_12 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_12, 0, x_2);
+lean_ctor_set(x_12, 1, x_4);
+lean_ctor_set(x_12, 2, x_11);
+x_13 = l_Substring_beq(x_10, x_12);
+lean_dec(x_12);
+lean_dec(x_10);
+return x_13;
+}
+}
+lean_object* l_String_endsWith___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_String_endsWith(x_1, x_2);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
 lean_object* l_String_trimRight(lean_object* x_1) {
 _start:
 {
diff --git a/stage0/stdlib/Init/Notation.c b/stage0/stdlib/Init/Notation.c
index 2bcb729ef7..444cf1de30 100644
--- a/stage0/stdlib/Init/Notation.c
+++ b/stage0/stdlib/Init/Notation.c
@@ -878,7 +878,6 @@ lean_object* l_stx___x3c_x7c_x3e_____closed__6;
 lean_object* l_term___x2f_____closed__5;
 lean_object* l_term___x3c_____closed__5;
 lean_object* l_prioHigh___closed__1;
-lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Parser_Tactic_constructor___closed__3;
 lean_object* l_termIfLet___x3a_x3d__Then__Else_____closed__16;
 lean_object* l_myMacro____x40_Init_Notation___hyg_4167____closed__1;
@@ -1415,7 +1414,6 @@ lean_object* l_Lean_Parser_Tactic_tacticHave_x27_____x3a_x3d_____closed__3;
 lean_object* l_term___x2b_x2b_____closed__1;
 lean_object* l_stx___x3c_x7c_x3e_____closed__7;
 lean_object* l_Lean_Parser_Tactic_changeWith___closed__6;
-lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
 lean_object* l_Lean_Parser_Tactic_simpPre___closed__2;
 lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_19379____closed__2;
 lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_16902____closed__1;
@@ -34975,7 +34973,7 @@ static lean_object* _init_l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hy
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("haveIdLhs");
+x_1 = lean_mk_string("typeSpec");
 return x_1;
 }
 }
@@ -34989,24 +34987,6 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("typeSpec");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Notation___hyg_1997____closed__2;
-x_2 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
-x_3 = lean_name_mk_string(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -35036,169 +35016,167 @@ x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_
 x_13 = !lean_is_exclusive(x_12);
 if (x_13 == 0)
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
 x_14 = lean_ctor_get(x_12, 0);
 x_15 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17105____closed__2;
 lean_inc(x_14);
 x_16 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_16, 0, x_14);
 lean_ctor_set(x_16, 1, x_15);
-x_17 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
+x_17 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
+x_18 = lean_array_push(x_17, x_9);
+x_19 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
+x_20 = lean_array_push(x_18, x_19);
+x_21 = l_Lean_nullKind___closed__2;
+x_22 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_22, 0, x_21);
+lean_ctor_set(x_22, 1, x_20);
+x_23 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_inc(x_14);
-x_18 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_18, 0, x_14);
-lean_ctor_set(x_18, 1, x_17);
-x_19 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
+x_24 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_24, 0, x_14);
+lean_ctor_set(x_24, 1, x_23);
+x_25 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
 lean_inc(x_14);
-x_20 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_20, 0, x_14);
-lean_ctor_set(x_20, 1, x_19);
-x_21 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
-x_22 = lean_array_push(x_21, x_20);
-x_23 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
-x_24 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_24, 0, x_23);
-lean_ctor_set(x_24, 1, x_22);
-x_25 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
-x_26 = lean_array_push(x_25, x_18);
-x_27 = lean_array_push(x_26, x_24);
-x_28 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
-x_29 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_29, 0, x_28);
-lean_ctor_set(x_29, 1, x_27);
-x_30 = lean_array_push(x_21, x_29);
-x_31 = l_Lean_nullKind___closed__2;
-x_32 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_32, 0, x_31);
-lean_ctor_set(x_32, 1, x_30);
-x_33 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_34 = lean_array_push(x_33, x_9);
-x_35 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
-x_36 = lean_array_push(x_34, x_35);
-x_37 = lean_array_push(x_36, x_32);
-x_38 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
-x_39 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_37);
-x_40 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
-x_41 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_41, 0, x_14);
-lean_ctor_set(x_41, 1, x_40);
-x_42 = lean_array_push(x_33, x_39);
-x_43 = lean_array_push(x_42, x_41);
-x_44 = lean_array_push(x_43, x_11);
-x_45 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_45);
-lean_ctor_set(x_46, 1, x_44);
-x_47 = lean_array_push(x_21, x_46);
-x_48 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
-x_49 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_47);
-x_50 = lean_array_push(x_25, x_16);
-x_51 = lean_array_push(x_50, x_49);
-x_52 = l_Lean_Parser_Tactic_tacticHave_____closed__2;
-x_53 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_51);
-x_54 = lean_array_push(x_21, x_53);
-x_55 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_55, 0, x_31);
-lean_ctor_set(x_55, 1, x_54);
-x_56 = lean_array_push(x_21, x_55);
-x_57 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
-x_58 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set(x_58, 1, x_56);
-lean_ctor_set(x_12, 0, x_58);
+x_26 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_26, 0, x_14);
+lean_ctor_set(x_26, 1, x_25);
+x_27 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+x_28 = lean_array_push(x_27, x_26);
+x_29 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
+x_30 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_28);
+x_31 = lean_array_push(x_17, x_24);
+x_32 = lean_array_push(x_31, x_30);
+x_33 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
+x_34 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_34, 0, x_33);
+lean_ctor_set(x_34, 1, x_32);
+x_35 = lean_array_push(x_27, x_34);
+x_36 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_36, 0, x_21);
+lean_ctor_set(x_36, 1, x_35);
+x_37 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
+x_38 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_38, 0, x_14);
+lean_ctor_set(x_38, 1, x_37);
+x_39 = l_myMacro____x40_Init_Notation___hyg_928____closed__7;
+x_40 = lean_array_push(x_39, x_22);
+x_41 = lean_array_push(x_40, x_36);
+x_42 = lean_array_push(x_41, x_38);
+x_43 = lean_array_push(x_42, x_11);
+x_44 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
+x_45 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_45, 0, x_44);
+lean_ctor_set(x_45, 1, x_43);
+x_46 = lean_array_push(x_27, x_45);
+x_47 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
+x_48 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_48, 0, x_47);
+lean_ctor_set(x_48, 1, x_46);
+x_49 = lean_array_push(x_17, x_16);
+x_50 = lean_array_push(x_49, x_48);
+x_51 = l_Lean_Parser_Tactic_tacticHave_____closed__2;
+x_52 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_52, 0, x_51);
+lean_ctor_set(x_52, 1, x_50);
+x_53 = lean_array_push(x_27, x_52);
+x_54 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_54, 0, x_21);
+lean_ctor_set(x_54, 1, x_53);
+x_55 = lean_array_push(x_27, x_54);
+x_56 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
+x_57 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_57, 0, x_56);
+lean_ctor_set(x_57, 1, x_55);
+lean_ctor_set(x_12, 0, x_57);
 return x_12;
 }
 else
 {
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 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; 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; 
-x_59 = lean_ctor_get(x_12, 0);
-x_60 = lean_ctor_get(x_12, 1);
-lean_inc(x_60);
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 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; 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_58 = lean_ctor_get(x_12, 0);
+x_59 = lean_ctor_get(x_12, 1);
 lean_inc(x_59);
+lean_inc(x_58);
 lean_dec(x_12);
-x_61 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17105____closed__2;
-lean_inc(x_59);
-x_62 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_62, 0, x_59);
-lean_ctor_set(x_62, 1, x_61);
-x_63 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
-lean_inc(x_59);
-x_64 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_64, 0, x_59);
-lean_ctor_set(x_64, 1, x_63);
-x_65 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
-lean_inc(x_59);
-x_66 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_66, 0, x_59);
-lean_ctor_set(x_66, 1, x_65);
-x_67 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
-x_68 = lean_array_push(x_67, x_66);
-x_69 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
-x_70 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_70, 1, x_68);
-x_71 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
-x_72 = lean_array_push(x_71, x_64);
-x_73 = lean_array_push(x_72, x_70);
-x_74 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_60 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17105____closed__2;
+lean_inc(x_58);
+x_61 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_61, 0, x_58);
+lean_ctor_set(x_61, 1, x_60);
+x_62 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
+x_63 = lean_array_push(x_62, x_9);
+x_64 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
+x_65 = lean_array_push(x_63, x_64);
+x_66 = l_Lean_nullKind___closed__2;
+x_67 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_67, 0, x_66);
+lean_ctor_set(x_67, 1, x_65);
+x_68 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
+lean_inc(x_58);
+x_69 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_69, 0, x_58);
+lean_ctor_set(x_69, 1, x_68);
+x_70 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
+lean_inc(x_58);
+x_71 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_71, 0, x_58);
+lean_ctor_set(x_71, 1, x_70);
+x_72 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+x_73 = lean_array_push(x_72, x_71);
+x_74 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
 x_75 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_75, 0, x_74);
 lean_ctor_set(x_75, 1, x_73);
-x_76 = lean_array_push(x_67, x_75);
-x_77 = l_Lean_nullKind___closed__2;
-x_78 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_78, 0, x_77);
-lean_ctor_set(x_78, 1, x_76);
-x_79 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_80 = lean_array_push(x_79, x_9);
-x_81 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
-x_82 = lean_array_push(x_80, x_81);
-x_83 = lean_array_push(x_82, x_78);
-x_84 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
-x_85 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_83);
-x_86 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
-x_87 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_87, 0, x_59);
-lean_ctor_set(x_87, 1, x_86);
-x_88 = lean_array_push(x_79, x_85);
-x_89 = lean_array_push(x_88, x_87);
-x_90 = lean_array_push(x_89, x_11);
-x_91 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
-x_92 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_92, 0, x_91);
-lean_ctor_set(x_92, 1, x_90);
-x_93 = lean_array_push(x_67, x_92);
-x_94 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
-x_95 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_95, 0, x_94);
-lean_ctor_set(x_95, 1, x_93);
-x_96 = lean_array_push(x_71, x_62);
-x_97 = lean_array_push(x_96, x_95);
-x_98 = l_Lean_Parser_Tactic_tacticHave_____closed__2;
+x_76 = lean_array_push(x_62, x_69);
+x_77 = lean_array_push(x_76, x_75);
+x_78 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
+x_79 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_79, 0, x_78);
+lean_ctor_set(x_79, 1, x_77);
+x_80 = lean_array_push(x_72, x_79);
+x_81 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_81, 0, x_66);
+lean_ctor_set(x_81, 1, x_80);
+x_82 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
+x_83 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_83, 0, x_58);
+lean_ctor_set(x_83, 1, x_82);
+x_84 = l_myMacro____x40_Init_Notation___hyg_928____closed__7;
+x_85 = lean_array_push(x_84, x_67);
+x_86 = lean_array_push(x_85, x_81);
+x_87 = lean_array_push(x_86, x_83);
+x_88 = lean_array_push(x_87, x_11);
+x_89 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
+x_90 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_90, 0, x_89);
+lean_ctor_set(x_90, 1, x_88);
+x_91 = lean_array_push(x_72, x_90);
+x_92 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
+x_93 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_93, 0, x_92);
+lean_ctor_set(x_93, 1, x_91);
+x_94 = lean_array_push(x_62, x_61);
+x_95 = lean_array_push(x_94, x_93);
+x_96 = l_Lean_Parser_Tactic_tacticHave_____closed__2;
+x_97 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_97, 0, x_96);
+lean_ctor_set(x_97, 1, x_95);
+x_98 = lean_array_push(x_72, x_97);
 x_99 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_99, 0, x_98);
-lean_ctor_set(x_99, 1, x_97);
-x_100 = lean_array_push(x_67, x_99);
-x_101 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_101, 0, x_77);
-lean_ctor_set(x_101, 1, x_100);
-x_102 = lean_array_push(x_67, x_101);
-x_103 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
-x_104 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_104, 0, x_103);
-lean_ctor_set(x_104, 1, x_102);
-x_105 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_105, 0, x_104);
-lean_ctor_set(x_105, 1, x_60);
-return x_105;
+lean_ctor_set(x_99, 0, x_66);
+lean_ctor_set(x_99, 1, x_98);
+x_100 = lean_array_push(x_72, x_99);
+x_101 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
+x_102 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_102, 0, x_101);
+lean_ctor_set(x_102, 1, x_100);
+x_103 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_103, 0, x_102);
+lean_ctor_set(x_103, 1, x_59);
+return x_103;
 }
 }
 }
@@ -37296,169 +37274,167 @@ x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_
 x_13 = !lean_is_exclusive(x_12);
 if (x_13 == 0)
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
 x_14 = lean_ctor_get(x_12, 0);
 x_15 = l_Lean_Parser_Tactic_tacticHave_x27_____x3a_x3d_____closed__3;
 lean_inc(x_14);
 x_16 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_16, 0, x_14);
 lean_ctor_set(x_16, 1, x_15);
-x_17 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
+x_17 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
+x_18 = lean_array_push(x_17, x_9);
+x_19 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
+x_20 = lean_array_push(x_18, x_19);
+x_21 = l_Lean_nullKind___closed__2;
+x_22 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_22, 0, x_21);
+lean_ctor_set(x_22, 1, x_20);
+x_23 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_inc(x_14);
-x_18 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_18, 0, x_14);
-lean_ctor_set(x_18, 1, x_17);
-x_19 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
+x_24 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_24, 0, x_14);
+lean_ctor_set(x_24, 1, x_23);
+x_25 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
 lean_inc(x_14);
-x_20 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_20, 0, x_14);
-lean_ctor_set(x_20, 1, x_19);
-x_21 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
-x_22 = lean_array_push(x_21, x_20);
-x_23 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
-x_24 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_24, 0, x_23);
-lean_ctor_set(x_24, 1, x_22);
-x_25 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
-x_26 = lean_array_push(x_25, x_18);
-x_27 = lean_array_push(x_26, x_24);
-x_28 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
-x_29 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_29, 0, x_28);
-lean_ctor_set(x_29, 1, x_27);
-x_30 = lean_array_push(x_21, x_29);
-x_31 = l_Lean_nullKind___closed__2;
-x_32 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_32, 0, x_31);
-lean_ctor_set(x_32, 1, x_30);
-x_33 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_34 = lean_array_push(x_33, x_9);
-x_35 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
-x_36 = lean_array_push(x_34, x_35);
-x_37 = lean_array_push(x_36, x_32);
-x_38 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
-x_39 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_37);
-x_40 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
-x_41 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_41, 0, x_14);
-lean_ctor_set(x_41, 1, x_40);
-x_42 = lean_array_push(x_33, x_39);
-x_43 = lean_array_push(x_42, x_41);
-x_44 = lean_array_push(x_43, x_11);
-x_45 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_45);
-lean_ctor_set(x_46, 1, x_44);
-x_47 = lean_array_push(x_21, x_46);
-x_48 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
-x_49 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_47);
-x_50 = lean_array_push(x_25, x_16);
-x_51 = lean_array_push(x_50, x_49);
-x_52 = l_Lean_Parser_Tactic_tacticHave_x27_____closed__2;
-x_53 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_51);
-x_54 = lean_array_push(x_21, x_53);
-x_55 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_55, 0, x_31);
-lean_ctor_set(x_55, 1, x_54);
-x_56 = lean_array_push(x_21, x_55);
-x_57 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
-x_58 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set(x_58, 1, x_56);
-lean_ctor_set(x_12, 0, x_58);
+x_26 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_26, 0, x_14);
+lean_ctor_set(x_26, 1, x_25);
+x_27 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+x_28 = lean_array_push(x_27, x_26);
+x_29 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
+x_30 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_28);
+x_31 = lean_array_push(x_17, x_24);
+x_32 = lean_array_push(x_31, x_30);
+x_33 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
+x_34 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_34, 0, x_33);
+lean_ctor_set(x_34, 1, x_32);
+x_35 = lean_array_push(x_27, x_34);
+x_36 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_36, 0, x_21);
+lean_ctor_set(x_36, 1, x_35);
+x_37 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
+x_38 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_38, 0, x_14);
+lean_ctor_set(x_38, 1, x_37);
+x_39 = l_myMacro____x40_Init_Notation___hyg_928____closed__7;
+x_40 = lean_array_push(x_39, x_22);
+x_41 = lean_array_push(x_40, x_36);
+x_42 = lean_array_push(x_41, x_38);
+x_43 = lean_array_push(x_42, x_11);
+x_44 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
+x_45 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_45, 0, x_44);
+lean_ctor_set(x_45, 1, x_43);
+x_46 = lean_array_push(x_27, x_45);
+x_47 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
+x_48 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_48, 0, x_47);
+lean_ctor_set(x_48, 1, x_46);
+x_49 = lean_array_push(x_17, x_16);
+x_50 = lean_array_push(x_49, x_48);
+x_51 = l_Lean_Parser_Tactic_tacticHave_x27_____closed__2;
+x_52 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_52, 0, x_51);
+lean_ctor_set(x_52, 1, x_50);
+x_53 = lean_array_push(x_27, x_52);
+x_54 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_54, 0, x_21);
+lean_ctor_set(x_54, 1, x_53);
+x_55 = lean_array_push(x_27, x_54);
+x_56 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
+x_57 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_57, 0, x_56);
+lean_ctor_set(x_57, 1, x_55);
+lean_ctor_set(x_12, 0, x_57);
 return x_12;
 }
 else
 {
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 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; 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; 
-x_59 = lean_ctor_get(x_12, 0);
-x_60 = lean_ctor_get(x_12, 1);
-lean_inc(x_60);
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 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; 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_58 = lean_ctor_get(x_12, 0);
+x_59 = lean_ctor_get(x_12, 1);
 lean_inc(x_59);
+lean_inc(x_58);
 lean_dec(x_12);
-x_61 = l_Lean_Parser_Tactic_tacticHave_x27_____x3a_x3d_____closed__3;
-lean_inc(x_59);
-x_62 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_62, 0, x_59);
-lean_ctor_set(x_62, 1, x_61);
-x_63 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
-lean_inc(x_59);
-x_64 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_64, 0, x_59);
-lean_ctor_set(x_64, 1, x_63);
-x_65 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
-lean_inc(x_59);
-x_66 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_66, 0, x_59);
-lean_ctor_set(x_66, 1, x_65);
-x_67 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
-x_68 = lean_array_push(x_67, x_66);
-x_69 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
-x_70 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_70, 1, x_68);
-x_71 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
-x_72 = lean_array_push(x_71, x_64);
-x_73 = lean_array_push(x_72, x_70);
-x_74 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_60 = l_Lean_Parser_Tactic_tacticHave_x27_____x3a_x3d_____closed__3;
+lean_inc(x_58);
+x_61 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_61, 0, x_58);
+lean_ctor_set(x_61, 1, x_60);
+x_62 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
+x_63 = lean_array_push(x_62, x_9);
+x_64 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
+x_65 = lean_array_push(x_63, x_64);
+x_66 = l_Lean_nullKind___closed__2;
+x_67 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_67, 0, x_66);
+lean_ctor_set(x_67, 1, x_65);
+x_68 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
+lean_inc(x_58);
+x_69 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_69, 0, x_58);
+lean_ctor_set(x_69, 1, x_68);
+x_70 = l_myMacro____x40_Init_Notation___hyg_13362____closed__14;
+lean_inc(x_58);
+x_71 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_71, 0, x_58);
+lean_ctor_set(x_71, 1, x_70);
+x_72 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+x_73 = lean_array_push(x_72, x_71);
+x_74 = l_myMacro____x40_Init_Notation___hyg_13362____closed__13;
 x_75 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_75, 0, x_74);
 lean_ctor_set(x_75, 1, x_73);
-x_76 = lean_array_push(x_67, x_75);
-x_77 = l_Lean_nullKind___closed__2;
-x_78 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_78, 0, x_77);
-lean_ctor_set(x_78, 1, x_76);
-x_79 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_80 = lean_array_push(x_79, x_9);
-x_81 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
-x_82 = lean_array_push(x_80, x_81);
-x_83 = lean_array_push(x_82, x_78);
-x_84 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
-x_85 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_83);
-x_86 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
-x_87 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_87, 0, x_59);
-lean_ctor_set(x_87, 1, x_86);
-x_88 = lean_array_push(x_79, x_85);
-x_89 = lean_array_push(x_88, x_87);
-x_90 = lean_array_push(x_89, x_11);
-x_91 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
-x_92 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_92, 0, x_91);
-lean_ctor_set(x_92, 1, x_90);
-x_93 = lean_array_push(x_67, x_92);
-x_94 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
-x_95 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_95, 0, x_94);
-lean_ctor_set(x_95, 1, x_93);
-x_96 = lean_array_push(x_71, x_62);
-x_97 = lean_array_push(x_96, x_95);
-x_98 = l_Lean_Parser_Tactic_tacticHave_x27_____closed__2;
+x_76 = lean_array_push(x_62, x_69);
+x_77 = lean_array_push(x_76, x_75);
+x_78 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
+x_79 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_79, 0, x_78);
+lean_ctor_set(x_79, 1, x_77);
+x_80 = lean_array_push(x_72, x_79);
+x_81 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_81, 0, x_66);
+lean_ctor_set(x_81, 1, x_80);
+x_82 = l_myMacro____x40_Init_Notation___hyg_14569____closed__11;
+x_83 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_83, 0, x_58);
+lean_ctor_set(x_83, 1, x_82);
+x_84 = l_myMacro____x40_Init_Notation___hyg_928____closed__7;
+x_85 = lean_array_push(x_84, x_67);
+x_86 = lean_array_push(x_85, x_81);
+x_87 = lean_array_push(x_86, x_83);
+x_88 = lean_array_push(x_87, x_11);
+x_89 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__3;
+x_90 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_90, 0, x_89);
+lean_ctor_set(x_90, 1, x_88);
+x_91 = lean_array_push(x_72, x_90);
+x_92 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__1;
+x_93 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_93, 0, x_92);
+lean_ctor_set(x_93, 1, x_91);
+x_94 = lean_array_push(x_62, x_61);
+x_95 = lean_array_push(x_94, x_93);
+x_96 = l_Lean_Parser_Tactic_tacticHave_x27_____closed__2;
+x_97 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_97, 0, x_96);
+lean_ctor_set(x_97, 1, x_95);
+x_98 = lean_array_push(x_72, x_97);
 x_99 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_99, 0, x_98);
-lean_ctor_set(x_99, 1, x_97);
-x_100 = lean_array_push(x_67, x_99);
-x_101 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_101, 0, x_77);
-lean_ctor_set(x_101, 1, x_100);
-x_102 = lean_array_push(x_67, x_101);
-x_103 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
-x_104 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_104, 0, x_103);
-lean_ctor_set(x_104, 1, x_102);
-x_105 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_105, 0, x_104);
-lean_ctor_set(x_105, 1, x_60);
-return x_105;
+lean_ctor_set(x_99, 0, x_66);
+lean_ctor_set(x_99, 1, x_98);
+x_100 = lean_array_push(x_72, x_99);
+x_101 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__2;
+x_102 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_102, 0, x_101);
+lean_ctor_set(x_102, 1, x_100);
+x_103 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_103, 0, x_102);
+lean_ctor_set(x_103, 1, x_59);
+return x_103;
 }
 }
 }
@@ -43598,10 +43574,6 @@ l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4 = _in
 lean_mark_persistent(l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4);
 l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5 = _init_l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5();
 lean_mark_persistent(l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5);
-l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6 = _init_l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6();
-lean_mark_persistent(l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6);
-l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7 = _init_l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7();
-lean_mark_persistent(l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7);
 l_Lean_Parser_Tactic_tacticSuffices_____closed__1 = _init_l_Lean_Parser_Tactic_tacticSuffices_____closed__1();
 lean_mark_persistent(l_Lean_Parser_Tactic_tacticSuffices_____closed__1);
 l_Lean_Parser_Tactic_tacticSuffices_____closed__2 = _init_l_Lean_Parser_Tactic_tacticSuffices_____closed__2();
diff --git a/stage0/stdlib/Init/NotationExtra.c b/stage0/stdlib/Init/NotationExtra.c
index 2f78fa40ff..b77aeb5e97 100644
--- a/stage0/stdlib/Init/NotationExtra.c
+++ b/stage0/stdlib/Init/NotationExtra.c
@@ -208,7 +208,6 @@ lean_object* l_command__ClassAbbrev_____x3a___x3a_x3d_____x2c___closed__10;
 lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_26____closed__2;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__8;
 lean_object* l_Lean_explicitBinders___closed__5;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__11;
 lean_object* l_Array_anyMUnsafe_any___at_Lean_expandExplicitBinders___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_term_u03a3_x27___x2c_____closed__8;
@@ -257,6 +256,7 @@ lean_object* l_myMacro____x40_Init_NotationExtra___hyg_4848____lambda__3___close
 uint8_t l_Array_anyMUnsafe_any___at_Lean_expandExplicitBinders___spec__1(lean_object*, lean_object*, size_t, size_t);
 lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__6;
 extern lean_object* l_Lean_instInhabitedSyntax;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_unifConstraintElem___closed__5;
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
 lean_object* l_Lean_command__Unif__hint______Where___x7c_x2d_u22a2_____closed__19;
@@ -287,6 +287,7 @@ lean_object* l_command__ClassAbbrev_____x3a___x3a_x3d_____x2c___closed__15;
 lean_object* l_myMacro____x40_Init_NotationExtra___hyg_2001____closed__2;
 lean_object* l_term_u03a3___x2c_____closed__3;
 lean_object* l_command__ClassAbbrev_____x3a___x3a_x3d_____x2c___closed__18;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 lean_object* l_tacticFunext____;
 lean_object* l_myMacro____x40_Init_NotationExtra___hyg_2001____boxed(lean_object*, lean_object*, lean_object*);
@@ -323,7 +324,6 @@ lean_object* l_Lean_Macro_throwError___rarg(lean_object*, lean_object*, lean_obj
 lean_object* l_command__ClassAbbrev_____x3a___x3a_x3d_____x2c___closed__22;
 lean_object* l_myMacro____x40_Init_NotationExtra___hyg_5403____boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Init_NotationExtra_0__Lean_mkHintBody___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
 lean_object* l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_command__Unif__hint______Where___x7c_x2d_u22a2_____closed__25;
 lean_object* l_Lean_termMacro_x2etrace_x5b_____x5d_____closed__6;
@@ -1488,7 +1488,7 @@ lean_ctor_set(x_66, 1, x_65);
 x_67 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_68 = lean_array_push(x_67, x_66);
 x_69 = lean_array_push(x_68, x_50);
-x_70 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_70 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_71 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_71, 0, x_70);
 lean_ctor_set(x_71, 1, x_69);
@@ -1628,7 +1628,7 @@ lean_ctor_set(x_139, 1, x_138);
 x_140 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_141 = lean_array_push(x_140, x_139);
 x_142 = lean_array_push(x_141, x_128);
-x_143 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_143 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_144 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_144, 0, x_143);
 lean_ctor_set(x_144, 1, x_142);
@@ -3254,7 +3254,7 @@ lean_ctor_set(x_105, 0, x_104);
 lean_ctor_set(x_105, 1, x_103);
 x_106 = lean_array_push(x_50, x_92);
 x_107 = lean_array_push(x_106, x_105);
-x_108 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_108 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_109 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_109, 0, x_108);
 lean_ctor_set(x_109, 1, x_107);
@@ -3421,7 +3421,7 @@ lean_ctor_set(x_200, 0, x_199);
 lean_ctor_set(x_200, 1, x_198);
 x_201 = lean_array_push(x_145, x_187);
 x_202 = lean_array_push(x_201, x_200);
-x_203 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_203 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_204 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_204, 0, x_203);
 lean_ctor_set(x_204, 1, x_202);
@@ -3624,7 +3624,7 @@ lean_ctor_set(x_312, 0, x_311);
 lean_ctor_set(x_312, 1, x_310);
 x_313 = lean_array_push(x_253, x_299);
 x_314 = lean_array_push(x_313, x_312);
-x_315 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_315 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_316 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_316, 0, x_315);
 lean_ctor_set(x_316, 1, x_314);
@@ -3802,7 +3802,7 @@ lean_ctor_set(x_411, 0, x_410);
 lean_ctor_set(x_411, 1, x_409);
 x_412 = lean_array_push(x_352, x_398);
 x_413 = lean_array_push(x_412, x_411);
-x_414 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_414 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_415 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_415, 0, x_414);
 lean_ctor_set(x_415, 1, x_413);
@@ -8412,7 +8412,7 @@ lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123;
 x_120 = lean_ctor_get(x_8, 0);
 lean_inc(x_120);
 lean_dec(x_8);
-x_121 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_121 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_122 = lean_name_mk_string(x_79, x_121);
 x_123 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_124 = lean_alloc_ctor(2, 2, 0);
@@ -8623,7 +8623,7 @@ lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237;
 x_234 = lean_ctor_get(x_8, 0);
 lean_inc(x_234);
 lean_dec(x_8);
-x_235 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_235 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_236 = lean_name_mk_string(x_192, x_235);
 x_237 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_238 = lean_alloc_ctor(2, 2, 0);
diff --git a/stage0/stdlib/Init/Prelude.c b/stage0/stdlib/Init/Prelude.c
index 19fecc36ce..1b7b3345f3 100644
--- a/stage0/stdlib/Init/Prelude.c
+++ b/stage0/stdlib/Init/Prelude.c
@@ -287,6 +287,7 @@ lean_object* l_Lean_Macro_instMonadQuotationMacroM___lambda__2(lean_object*, lea
 lean_object* l_namedPattern___rarg(lean_object*);
 lean_object* l_instSubNat___closed__1;
 uint8_t l_not(uint8_t);
+lean_object* l_min(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isIdent_match__1(lean_object*);
 uint32_t l_Char_utf8Size___closed__3;
 lean_object* l_instMonadStateOf(lean_object*, lean_object*, lean_object*);
@@ -330,6 +331,7 @@ lean_object* l_EStateM_modifyGet___rarg(lean_object*, lean_object*);
 lean_object* l_mixHash___boxed(lean_object*, lean_object*);
 uint8_t l_instDecidableEqList___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_EStateM_map(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_mixUSizeHash___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getId___boxed(lean_object*);
 lean_object* l_instMonadWithReaderOfReaderT___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Macro_instInhabitedMethods___lambda__1(lean_object*, lean_object*, lean_object*);
@@ -491,6 +493,7 @@ uint16_t lean_uint16_of_nat_mk(lean_object*);
 lean_object* l___private_Init_Prelude_0__Lean_assembleParts_match__1(lean_object*);
 lean_object* l_Lean_Syntax_setKind_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Prelude_0__Lean_assembleParts(lean_object*, lean_object*);
+lean_object* l_min___boxed(lean_object*, lean_object*);
 lean_object* l_EStateM_instOrElseEStateM(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_instDecidableEqFin___rarg(lean_object*, lean_object*);
 uint8_t l_Fin_decLt___rarg(lean_object*, lean_object*);
@@ -614,6 +617,7 @@ lean_object* l_Lean_Syntax_getHeadInfo_x3f___boxed(lean_object*);
 lean_object* l_String_utf8ByteSize_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_EStateM_instMonadEStateM___closed__6;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_max(lean_object*, lean_object*);
 lean_object* l_Lean_Macro_withIncRecDepth(lean_object*);
 lean_object* l_Lean_Name_append_match__1(lean_object*);
 lean_object* l_and_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
@@ -680,6 +684,7 @@ lean_object* l_Lean_Macro_getMethodsImp(lean_object*, lean_object*);
 lean_object* l_Lean_Name_hasMacroScopes___closed__1;
 lean_object* l_Lean_instMonadQuotation___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
+lean_object* l_max___boxed(lean_object*, lean_object*);
 lean_object* l_throwThe___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_UInt32_decEq___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_append_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -813,6 +818,7 @@ lean_object* l_Lean_Macro_instInhabitedMethodsRef___closed__1;
 lean_object* l_Eq_ndrec___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SourceInfo_getPos_x3f(lean_object*, uint8_t);
 lean_object* lean_simp_macro_scopes(lean_object*);
+lean_object* l_max___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getTailPos_x3f_loop_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_instMonadQuotationUnexpandM___closed__3;
 lean_object* l_EStateM_bind(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -862,6 +868,7 @@ lean_object* l_UInt64_size;
 lean_object* l_Monad_seqRight___default(lean_object*);
 lean_object* l_USize_ofNat32___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_hash___boxed(lean_object*);
+size_t lean_usize_mix_hash(size_t, size_t);
 lean_object* l_instHPow___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_defaultMaxRecDepth;
 lean_object* l_Applicative_seqLeft___default___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -904,6 +911,7 @@ lean_object* l_instMonadWithReaderOfReaderT(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_Macro_Context_maxRecDepth___default;
 lean_object* l_instDecidableAnd_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_instHAdd(lean_object*);
+lean_object* l_min___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Prelude_0__Lean_extractMacroScopesAux___closed__1;
 lean_object* l_List_toArrayAux_match__1(lean_object*, lean_object*);
 lean_object* l_unsafeCast___boxed(lean_object*, lean_object*, lean_object*);
@@ -1912,6 +1920,82 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_max___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; 
+lean_inc(x_2);
+lean_inc(x_3);
+x_4 = lean_apply_2(x_1, x_3, x_2);
+x_5 = lean_unbox(x_4);
+lean_dec(x_4);
+if (x_5 == 0)
+{
+lean_dec(x_2);
+return x_3;
+}
+else
+{
+lean_dec(x_3);
+return x_2;
+}
+}
+}
+lean_object* l_max(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_max___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_max___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_max(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+lean_object* l_min___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; 
+lean_inc(x_3);
+lean_inc(x_2);
+x_4 = lean_apply_2(x_1, x_2, x_3);
+x_5 = lean_unbox(x_4);
+lean_dec(x_4);
+if (x_5 == 0)
+{
+lean_dec(x_2);
+return x_3;
+}
+else
+{
+lean_dec(x_3);
+return x_2;
+}
+}
+}
+lean_object* l_min(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_min___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_min___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_min(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
 lean_object* l_instHAdd___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -7642,6 +7726,19 @@ x_2 = l_EStateM_nonBacktrackable___closed__3;
 return x_2;
 }
 }
+lean_object* l_mixUSizeHash___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+size_t x_3; size_t x_4; size_t x_5; lean_object* x_6; 
+x_3 = lean_unbox_usize(x_1);
+lean_dec(x_1);
+x_4 = lean_unbox_usize(x_2);
+lean_dec(x_2);
+x_5 = lean_usize_mix_hash(x_3, x_4);
+x_6 = lean_box_usize(x_5);
+return x_6;
+}
+}
 lean_object* l_mixHash___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
diff --git a/stage0/stdlib/Init/System/FilePath.c b/stage0/stdlib/Init/System/FilePath.c
index 1d040d2277..041e002721 100644
--- a/stage0/stdlib/Init/System/FilePath.c
+++ b/stage0/stdlib/Init/System/FilePath.c
@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Init.System.FilePath
-// Imports: Init.System.Platform Init.Data.String.Basic
+// Imports: Init.System.Platform Init.Data.String.Basic Init.Data.Repr Init.Data.ToString.Basic
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -14,55 +14,239 @@
 extern "C" {
 #endif
 lean_object* l_List_reverse___rarg(lean_object*);
-lean_object* l_System_FilePath_exeSuffix___closed__1;
+lean_object* l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23__match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_push(lean_object*, uint32_t);
+lean_object* l_System_instDecidableEqFilePath___boxed(lean_object*, lean_object*);
+lean_object* l_System_instReprFilePath(lean_object*, lean_object*);
+lean_object* l_System_FilePath_fileName_match__1___rarg(lean_object*, lean_object*, lean_object*);
 extern uint8_t l_System_Platform_isWindows;
-lean_object* l_String_split___at_System_FilePath_splitSearchPath___spec__1___boxed(lean_object*);
+uint8_t l_System_FilePath_isRelative(lean_object*);
+lean_object* l_System_FilePath_join(lean_object*, lean_object*);
+uint8_t l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23_(lean_object*, lean_object*);
+lean_object* l_System_FilePath_isRelative___boxed(lean_object*);
 extern uint8_t l_System_Platform_isOSX;
+uint32_t l_System_SearchPath_separator___closed__1;
 lean_object* l_String_revPosOf(lean_object*, uint32_t);
 uint8_t l_System_FilePath_isCaseInsensitive;
+lean_object* l_String_splitAux___at_System_SearchPath_parse___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_String_mapAux___at_System_FilePath_normalize___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_System_mkFilePath(lean_object*);
 lean_object* l_System_FilePath_pathSeparators___closed__2___boxed__const__1;
-lean_object* l_String_splitAux___at_System_FilePath_splitSearchPath___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_instReprFilePath___closed__2;
+lean_object* l_System_FilePath_withFileName_match__1(lean_object*);
+lean_object* l_List_elem___at_System_FilePath_normalize___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_String_split___at_System_SearchPath_parse___spec__1(lean_object*);
+lean_object* l_System_FilePath_fileName___closed__1;
 extern lean_object* l_Lean_instInhabitedParserDescr___closed__1;
+lean_object* l_System_FilePath_components(lean_object*);
+lean_object* l_System_instReprFilePath___boxed(lean_object*, lean_object*);
+lean_object* l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23__match__1(lean_object*);
+uint8_t l_System_FilePath_isAbsolute(lean_object*);
+uint8_t l_List_contains___at___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___spec__1(lean_object*, uint32_t);
+lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* lean_string_utf8_set(lean_object*, lean_object*, uint32_t);
-lean_object* l_System_FilePath_splitSearchPath(lean_object*);
 lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
-lean_object* l_List_foldr___at_System_FilePath_normalizePath___spec__1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_String_mapAux___at_System_FilePath_normalizePath___spec__4(lean_object*, lean_object*);
+lean_object* l_String_split___at_System_SearchPath_parse___spec__1___boxed(lean_object*);
+lean_object* l_String_splitOn(lean_object*, lean_object*);
+lean_object* lean_string_utf8_byte_size(lean_object*);
+lean_object* l_System_instReprFilePath___closed__1;
+lean_object* l_List_contains___at___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___spec__1___boxed(lean_object*, lean_object*);
+lean_object* lean_nat_add(lean_object*, lean_object*);
+lean_object* l_System_FilePath_fileStem_match__1(lean_object*);
 lean_object* l_System_FilePath_pathSeparators;
+lean_object* l_System_FilePath_fileStem_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_utf8_next(lean_object*, lean_object*);
+lean_object* l_List_map___at_System_SearchPath_parse___spec__3(lean_object*);
+lean_object* l_System_FilePath_isAbsolute___boxed(lean_object*);
+lean_object* l_System_FilePath_withExtension_match__1(lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
-uint8_t l_System_FilePath_normalizePath___closed__2;
 lean_object* lean_nat_sub(lean_object*, lean_object*);
-lean_object* l_System_FilePath_normalizePath___closed__1;
-lean_object* l_System_FilePath_splitSearchPath___boxed(lean_object*);
-lean_object* l_System_FilePath_normalizePath(lean_object*);
+lean_object* l_System_SearchPath_toString___closed__1;
+lean_object* l_String_splitAux___at_System_SearchPath_parse___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_instInhabitedFilePath;
+lean_object* l_System_FilePath_normalize___closed__1;
+lean_object* l_System_instCoeStringFilePath___boxed(lean_object*);
+uint8_t l_System_FilePath_normalize___closed__2;
+lean_object* l_System_FilePath_normalize(lean_object*, uint8_t);
+lean_object* l_System_FilePath_normalize___boxed(lean_object*, lean_object*);
 uint32_t l_System_FilePath_pathSeparator___closed__1;
+lean_object* l_System_FilePath_instHDivFilePathStringFilePath(lean_object*, lean_object*);
+lean_object* l_System_FilePath_withFileName(lean_object*, lean_object*);
 uint32_t l_System_FilePath_pathSeparator;
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 uint8_t l_System_FilePath_isCaseInsensitive___closed__1;
-uint32_t l_System_FilePath_searchPathSeparator___closed__1;
-lean_object* l_System_FilePath_exeSuffix___closed__2;
-lean_object* l_String_mapAux___at_System_FilePath_normalizePath___spec__2(lean_object*, lean_object*);
-lean_object* l_String_splitAux___at_System_FilePath_splitSearchPath___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_String_revFind(lean_object*, lean_object*);
+lean_object* l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___boxed(lean_object*);
+lean_object* l_System_FilePath_withFileName___boxed(lean_object*, lean_object*);
+lean_object* l_System_FilePath_instDivFilePath___closed__1;
+lean_object* l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___closed__1;
 uint32_t l_System_FilePath_extSeparator;
+lean_object* l_System_FilePath_exeExtension;
+lean_object* l_System_FilePath_parent___boxed(lean_object*);
+lean_object* l_System_instCoeStringFilePath(lean_object*);
+lean_object* l_System_FilePath_join___boxed(lean_object*, lean_object*);
+lean_object* l_System_FilePath_exeExtension___closed__1;
+lean_object* l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep(lean_object*);
+lean_object* l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23____boxed(lean_object*, lean_object*);
+lean_object* l_List_map___at_System_SearchPath_toString___spec__1(lean_object*);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 lean_object* l_String_intercalate(lean_object*, lean_object*);
-uint32_t l_System_FilePath_searchPathSeparator;
+uint8_t l_String_isEmpty(lean_object*);
+lean_object* l_String_mapAux___at_System_FilePath_normalize___spec__2(uint8_t, lean_object*, lean_object*);
+lean_object* l_System_FilePath_instDivFilePath;
+uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_System_FilePath_fileName(lean_object*);
+lean_object* l_String_quote(lean_object*);
+lean_object* l_System_FilePath_withExtension___boxed(lean_object*, lean_object*);
+lean_object* l_System_FilePath_exeExtension___closed__2;
 lean_object* l_System_FilePath_pathSeparators___closed__3;
-lean_object* l_System_mkFilePath___closed__1;
-lean_object* l_List_foldr___at_System_FilePath_normalizePath___spec__3___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_System_SearchPath_toString(lean_object*);
+lean_object* l_System_FilePath_fileName_match__1(lean_object*);
+lean_object* l_Char_toLower(uint32_t);
+lean_object* l_System_FilePath_withExtension_match__1___rarg(lean_object*, lean_object*, lean_object*);
+uint8_t l_List_elem___at_System_FilePath_normalize___spec__1(uint32_t, lean_object*);
+lean_object* l_System_FilePath_instHDivFilePathStringFilePath___boxed(lean_object*, lean_object*);
+uint32_t l_System_SearchPath_separator;
 lean_object* l_System_FilePath_pathSeparators___closed__2;
-uint8_t l_List_foldr___at_System_FilePath_normalizePath___spec__3(uint32_t, uint8_t, lean_object*);
+lean_object* l_System_SearchPath_parse(lean_object*);
 lean_object* l_System_FilePath_pathSeparators___closed__1;
+lean_object* l_System_FilePath_extension(lean_object*);
+uint8_t l_System_instDecidableEqFilePath(lean_object*, lean_object*);
 lean_object* l_System_FilePath_parent(lean_object*);
-uint8_t l_List_foldr___at_System_FilePath_normalizePath___spec__1(uint32_t, uint8_t, lean_object*);
+lean_object* l_System_instToStringFilePath(lean_object*);
+lean_object* l_System_FilePath_withExtension(lean_object*, lean_object*);
+lean_object* l_System_FilePath_fileStem(lean_object*);
+lean_object* l_System_instToStringFilePath___boxed(lean_object*);
 lean_object* l_System_FilePath_pathSeparators___closed__1___boxed__const__1;
-lean_object* l_System_FilePath_exeSuffix;
 lean_object* l_List_lengthAux___rarg(lean_object*, lean_object*);
-lean_object* l_String_split___at_System_FilePath_splitSearchPath___spec__1(lean_object*);
+lean_object* l_System_FilePath_withFileName_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_join___closed__1;
 uint8_t lean_string_utf8_at_end(lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_tactic_xb7_x2e_____closed__5;
+lean_object* l_System_SearchPath_parse___boxed(lean_object*);
+uint8_t lean_string_dec_eq(lean_object*, lean_object*);
+lean_object* l_Repr_addAppParen(lean_object*, lean_object*);
+static lean_object* _init_l_System_instInhabitedFilePath() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_instInhabitedParserDescr___closed__1;
+return x_1;
+}
+}
+lean_object* l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23__match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_2(x_3, x_1, x_2);
+return x_4;
+}
+}
+lean_object* l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23__match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23__match__1___rarg), 3, 0);
+return x_2;
+}
+}
+uint8_t l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23_(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = lean_string_dec_eq(x_1, x_2);
+return x_3;
+}
+}
+lean_object* l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l___private_Init_System_FilePath_0__System_decEqFilePath____x40_Init_System_FilePath___hyg_23_(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+uint8_t l_System_instDecidableEqFilePath(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = lean_string_dec_eq(x_1, x_2);
+return x_3;
+}
+}
+lean_object* l_System_instDecidableEqFilePath___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_System_instDecidableEqFilePath(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+static lean_object* _init_l_System_instReprFilePath___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("FilePath.mk ");
+return x_1;
+}
+}
+static lean_object* _init_l_System_instReprFilePath___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_System_instReprFilePath___closed__1;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l_System_instReprFilePath(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = l_String_quote(x_1);
+x_4 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_4, 0, x_3);
+x_5 = l_System_instReprFilePath___closed__2;
+x_6 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_6, 0, x_5);
+lean_ctor_set(x_6, 1, x_4);
+x_7 = l_Repr_addAppParen(x_6, x_2);
+return x_7;
+}
+}
+lean_object* l_System_instReprFilePath___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_instReprFilePath(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_System_instToStringFilePath(lean_object* x_1) {
+_start:
+{
+lean_inc(x_1);
+return x_1;
+}
+}
+lean_object* l_System_instToStringFilePath___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_System_instToStringFilePath(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
 static uint32_t _init_l_System_FilePath_pathSeparator___closed__1() {
 _start:
 {
@@ -159,7 +343,1174 @@ x_1 = l_System_FilePath_pathSeparators___closed__3;
 return x_1;
 }
 }
-static uint32_t _init_l_System_FilePath_searchPathSeparator___closed__1() {
+static uint32_t _init_l_System_FilePath_extSeparator() {
+_start:
+{
+uint32_t x_1; 
+x_1 = 46;
+return x_1;
+}
+}
+static lean_object* _init_l_System_FilePath_exeExtension___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("exe");
+return x_1;
+}
+}
+static lean_object* _init_l_System_FilePath_exeExtension___closed__2() {
+_start:
+{
+uint8_t x_1; 
+x_1 = l_System_Platform_isWindows;
+if (x_1 == 0)
+{
+lean_object* x_2; 
+x_2 = l_Lean_instInhabitedParserDescr___closed__1;
+return x_2;
+}
+else
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_exeExtension___closed__1;
+return x_3;
+}
+}
+}
+static lean_object* _init_l_System_FilePath_exeExtension() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_System_FilePath_exeExtension___closed__2;
+return x_1;
+}
+}
+static uint8_t _init_l_System_FilePath_isCaseInsensitive___closed__1() {
+_start:
+{
+uint8_t x_1; 
+x_1 = l_System_Platform_isWindows;
+if (x_1 == 0)
+{
+uint8_t x_2; 
+x_2 = l_System_Platform_isOSX;
+return x_2;
+}
+else
+{
+uint8_t x_3; 
+x_3 = 1;
+return x_3;
+}
+}
+}
+static uint8_t _init_l_System_FilePath_isCaseInsensitive() {
+_start:
+{
+uint8_t x_1; 
+x_1 = l_System_FilePath_isCaseInsensitive___closed__1;
+return x_1;
+}
+}
+uint8_t l_List_elem___at_System_FilePath_normalize___spec__1(uint32_t x_1, lean_object* x_2) {
+_start:
+{
+if (lean_obj_tag(x_2) == 0)
+{
+uint8_t x_3; 
+x_3 = 0;
+return x_3;
+}
+else
+{
+lean_object* x_4; lean_object* x_5; uint32_t x_6; uint8_t x_7; 
+x_4 = lean_ctor_get(x_2, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_dec(x_2);
+x_6 = lean_unbox_uint32(x_4);
+lean_dec(x_4);
+x_7 = x_1 == x_6;
+if (x_7 == 0)
+{
+x_2 = x_5;
+goto _start;
+}
+else
+{
+uint8_t x_9; 
+lean_dec(x_5);
+x_9 = 1;
+return x_9;
+}
+}
+}
+}
+lean_object* l_String_mapAux___at_System_FilePath_normalize___spec__2(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; 
+x_4 = lean_string_utf8_at_end(x_3, x_2);
+if (x_4 == 0)
+{
+uint32_t x_5; lean_object* x_6; uint8_t x_7; 
+x_5 = lean_string_utf8_get(x_3, x_2);
+x_6 = l_System_FilePath_pathSeparators;
+x_7 = l_List_elem___at_System_FilePath_normalize___spec__1(x_5, x_6);
+if (x_7 == 0)
+{
+if (x_1 == 0)
+{
+lean_object* x_8; lean_object* x_9; 
+x_8 = lean_string_utf8_set(x_3, x_2, x_5);
+x_9 = lean_string_utf8_next(x_8, x_2);
+lean_dec(x_2);
+x_2 = x_9;
+x_3 = x_8;
+goto _start;
+}
+else
+{
+lean_object* x_11; uint32_t x_12; lean_object* x_13; lean_object* x_14; 
+x_11 = l_Char_toLower(x_5);
+x_12 = lean_unbox_uint32(x_11);
+lean_dec(x_11);
+x_13 = lean_string_utf8_set(x_3, x_2, x_12);
+x_14 = lean_string_utf8_next(x_13, x_2);
+lean_dec(x_2);
+x_2 = x_14;
+x_3 = x_13;
+goto _start;
+}
+}
+else
+{
+uint32_t x_16; lean_object* x_17; lean_object* x_18; 
+x_16 = l_System_FilePath_pathSeparator;
+x_17 = lean_string_utf8_set(x_3, x_2, x_16);
+x_18 = lean_string_utf8_next(x_17, x_2);
+lean_dec(x_2);
+x_2 = x_18;
+x_3 = x_17;
+goto _start;
+}
+}
+else
+{
+lean_dec(x_2);
+return x_3;
+}
+}
+}
+static lean_object* _init_l_System_FilePath_normalize___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_System_FilePath_pathSeparators;
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = l_List_lengthAux___rarg(x_1, x_2);
+return x_3;
+}
+}
+static uint8_t _init_l_System_FilePath_normalize___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; uint8_t x_3; 
+x_1 = l_System_FilePath_normalize___closed__1;
+x_2 = lean_unsigned_to_nat(1u);
+x_3 = lean_nat_dec_eq(x_1, x_2);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_normalize(lean_object* x_1, uint8_t x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = l_System_FilePath_normalize___closed__2;
+if (x_3 == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = l_String_mapAux___at_System_FilePath_normalize___spec__2(x_2, x_4, x_1);
+return x_5;
+}
+else
+{
+if (x_2 == 0)
+{
+return x_1;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+x_6 = lean_unsigned_to_nat(0u);
+x_7 = l_String_mapAux___at_System_FilePath_normalize___spec__2(x_2, x_6, x_1);
+return x_7;
+}
+}
+}
+}
+lean_object* l_List_elem___at_System_FilePath_normalize___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint32_t x_3; uint8_t x_4; lean_object* x_5; 
+x_3 = lean_unbox_uint32(x_1);
+lean_dec(x_1);
+x_4 = l_List_elem___at_System_FilePath_normalize___spec__1(x_3, x_2);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+lean_object* l_String_mapAux___at_System_FilePath_normalize___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_String_mapAux___at_System_FilePath_normalize___spec__2(x_4, x_2, x_3);
+return x_5;
+}
+}
+lean_object* l_System_FilePath_normalize___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = lean_unbox(x_2);
+lean_dec(x_2);
+x_4 = l_System_FilePath_normalize(x_1, x_3);
+return x_4;
+}
+}
+uint8_t l_System_FilePath_isAbsolute(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; uint32_t x_3; lean_object* x_4; uint8_t x_5; 
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = lean_string_utf8_get(x_1, x_2);
+x_4 = l_System_FilePath_pathSeparators;
+x_5 = l_List_elem___at_System_FilePath_normalize___spec__1(x_3, x_4);
+if (x_5 == 0)
+{
+uint8_t x_6; 
+x_6 = l_System_Platform_isWindows;
+if (x_6 == 0)
+{
+uint8_t x_7; 
+x_7 = 0;
+return x_7;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_string_utf8_byte_size(x_1);
+x_9 = lean_unsigned_to_nat(1u);
+x_10 = lean_nat_dec_le(x_9, x_8);
+lean_dec(x_8);
+if (x_10 == 0)
+{
+uint8_t x_11; 
+x_11 = 0;
+return x_11;
+}
+else
+{
+uint32_t x_12; uint32_t x_13; uint8_t x_14; 
+x_12 = lean_string_utf8_get(x_1, x_9);
+x_13 = 58;
+x_14 = x_12 == x_13;
+return x_14;
+}
+}
+}
+else
+{
+uint8_t x_15; 
+x_15 = 1;
+return x_15;
+}
+}
+}
+lean_object* l_System_FilePath_isAbsolute___boxed(lean_object* x_1) {
+_start:
+{
+uint8_t x_2; lean_object* x_3; 
+x_2 = l_System_FilePath_isAbsolute(x_1);
+lean_dec(x_1);
+x_3 = lean_box(x_2);
+return x_3;
+}
+}
+uint8_t l_System_FilePath_isRelative(lean_object* x_1) {
+_start:
+{
+uint8_t x_2; 
+x_2 = l_System_FilePath_isAbsolute(x_1);
+if (x_2 == 0)
+{
+uint8_t x_3; 
+x_3 = 1;
+return x_3;
+}
+else
+{
+uint8_t x_4; 
+x_4 = 0;
+return x_4;
+}
+}
+}
+lean_object* l_System_FilePath_isRelative___boxed(lean_object* x_1) {
+_start:
+{
+uint8_t x_2; lean_object* x_3; 
+x_2 = l_System_FilePath_isRelative(x_1);
+lean_dec(x_1);
+x_3 = lean_box(x_2);
+return x_3;
+}
+}
+static lean_object* _init_l_System_FilePath_join___closed__1() {
+_start:
+{
+lean_object* x_1; uint32_t x_2; lean_object* x_3; 
+x_1 = l_Lean_instInhabitedParserDescr___closed__1;
+x_2 = l_System_FilePath_pathSeparator;
+x_3 = lean_string_push(x_1, x_2);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_join(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = l_System_FilePath_isAbsolute(x_2);
+if (x_3 == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = l_System_FilePath_join___closed__1;
+x_5 = lean_string_append(x_1, x_4);
+x_6 = lean_string_append(x_5, x_2);
+return x_6;
+}
+else
+{
+lean_dec(x_1);
+lean_inc(x_2);
+return x_2;
+}
+}
+}
+lean_object* l_System_FilePath_join___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_join(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+static lean_object* _init_l_System_FilePath_instDivFilePath___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_System_FilePath_join___boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_System_FilePath_instDivFilePath() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_System_FilePath_instDivFilePath___closed__1;
+return x_1;
+}
+}
+lean_object* l_System_FilePath_instHDivFilePathStringFilePath(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_join(x_1, x_2);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_instHDivFilePathStringFilePath___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_instHDivFilePathStringFilePath(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+uint8_t l_List_contains___at___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___spec__1(lean_object* x_1, uint32_t x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = l_List_elem___at_System_FilePath_normalize___spec__1(x_2, x_1);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_System_FilePath_pathSeparators;
+x_2 = lean_alloc_closure((void*)(l_List_contains___at___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___spec__1___boxed), 2, 1);
+lean_closure_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; 
+x_2 = l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___closed__1;
+x_3 = l_String_revFind(x_1, x_2);
+return x_3;
+}
+}
+lean_object* l_List_contains___at___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint32_t x_3; uint8_t x_4; lean_object* x_5; 
+x_3 = lean_unbox_uint32(x_2);
+lean_dec(x_2);
+x_4 = l_List_contains___at___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___spec__1(x_1, x_3);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+lean_object* l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
+lean_object* l_System_FilePath_parent(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep(x_1);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
+}
+else
+{
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_2);
+if (x_4 == 0)
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_unsigned_to_nat(0u);
+x_7 = lean_string_utf8_extract(x_1, x_6, x_5);
+lean_dec(x_5);
+lean_ctor_set(x_2, 0, x_7);
+return x_2;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_8 = lean_ctor_get(x_2, 0);
+lean_inc(x_8);
+lean_dec(x_2);
+x_9 = lean_unsigned_to_nat(0u);
+x_10 = lean_string_utf8_extract(x_1, x_9, x_8);
+lean_dec(x_8);
+x_11 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_11, 0, x_10);
+return x_11;
+}
+}
+}
+}
+lean_object* l_System_FilePath_parent___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_System_FilePath_parent(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
+lean_object* l_System_FilePath_fileName_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_System_FilePath_fileName_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_System_FilePath_fileName_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+static lean_object* _init_l_System_FilePath_fileName___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("..");
+return x_1;
+}
+}
+lean_object* l_System_FilePath_fileName(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep(x_1);
+if (lean_obj_tag(x_2) == 0)
+{
+uint8_t x_3; 
+x_3 = l_String_isEmpty(x_1);
+if (x_3 == 0)
+{
+lean_object* x_4; uint8_t x_5; 
+x_4 = l_Lean_Parser_Tactic_tactic_xb7_x2e_____closed__5;
+x_5 = lean_string_dec_eq(x_1, x_4);
+if (x_5 == 0)
+{
+lean_object* x_6; uint8_t x_7; 
+x_6 = l_System_FilePath_fileName___closed__1;
+x_7 = lean_string_dec_eq(x_1, x_6);
+if (x_7 == 0)
+{
+lean_object* x_8; 
+x_8 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_8, 0, x_1);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_1);
+x_9 = lean_box(0);
+return x_9;
+}
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_1);
+x_10 = lean_box(0);
+return x_10;
+}
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_1);
+x_11 = lean_box(0);
+return x_11;
+}
+}
+else
+{
+uint8_t x_12; 
+x_12 = !lean_is_exclusive(x_2);
+if (x_12 == 0)
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+x_13 = lean_ctor_get(x_2, 0);
+x_14 = lean_unsigned_to_nat(1u);
+x_15 = lean_nat_add(x_13, x_14);
+lean_dec(x_13);
+x_16 = lean_string_utf8_byte_size(x_1);
+x_17 = lean_string_utf8_extract(x_1, x_15, x_16);
+lean_dec(x_16);
+lean_dec(x_15);
+lean_dec(x_1);
+x_18 = l_String_isEmpty(x_17);
+if (x_18 == 0)
+{
+lean_object* x_19; uint8_t x_20; 
+x_19 = l_Lean_Parser_Tactic_tactic_xb7_x2e_____closed__5;
+x_20 = lean_string_dec_eq(x_17, x_19);
+if (x_20 == 0)
+{
+lean_object* x_21; uint8_t x_22; 
+x_21 = l_System_FilePath_fileName___closed__1;
+x_22 = lean_string_dec_eq(x_17, x_21);
+if (x_22 == 0)
+{
+lean_ctor_set(x_2, 0, x_17);
+return x_2;
+}
+else
+{
+lean_object* x_23; 
+lean_dec(x_17);
+lean_free_object(x_2);
+x_23 = lean_box(0);
+return x_23;
+}
+}
+else
+{
+lean_object* x_24; 
+lean_dec(x_17);
+lean_free_object(x_2);
+x_24 = lean_box(0);
+return x_24;
+}
+}
+else
+{
+lean_object* x_25; 
+lean_dec(x_17);
+lean_free_object(x_2);
+x_25 = lean_box(0);
+return x_25;
+}
+}
+else
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; 
+x_26 = lean_ctor_get(x_2, 0);
+lean_inc(x_26);
+lean_dec(x_2);
+x_27 = lean_unsigned_to_nat(1u);
+x_28 = lean_nat_add(x_26, x_27);
+lean_dec(x_26);
+x_29 = lean_string_utf8_byte_size(x_1);
+x_30 = lean_string_utf8_extract(x_1, x_28, x_29);
+lean_dec(x_29);
+lean_dec(x_28);
+lean_dec(x_1);
+x_31 = l_String_isEmpty(x_30);
+if (x_31 == 0)
+{
+lean_object* x_32; uint8_t x_33; 
+x_32 = l_Lean_Parser_Tactic_tactic_xb7_x2e_____closed__5;
+x_33 = lean_string_dec_eq(x_30, x_32);
+if (x_33 == 0)
+{
+lean_object* x_34; uint8_t x_35; 
+x_34 = l_System_FilePath_fileName___closed__1;
+x_35 = lean_string_dec_eq(x_30, x_34);
+if (x_35 == 0)
+{
+lean_object* x_36; 
+x_36 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_36, 0, x_30);
+return x_36;
+}
+else
+{
+lean_object* x_37; 
+lean_dec(x_30);
+x_37 = lean_box(0);
+return x_37;
+}
+}
+else
+{
+lean_object* x_38; 
+lean_dec(x_30);
+x_38 = lean_box(0);
+return x_38;
+}
+}
+else
+{
+lean_object* x_39; 
+lean_dec(x_30);
+x_39 = lean_box(0);
+return x_39;
+}
+}
+}
+}
+}
+lean_object* l_System_FilePath_fileStem_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_4, x_5);
+return x_6;
+}
+else
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_unsigned_to_nat(0u);
+x_9 = lean_nat_dec_eq(x_7, x_8);
+if (x_9 == 0)
+{
+lean_object* x_10; 
+lean_dec(x_2);
+x_10 = lean_apply_1(x_3, x_7);
+return x_10;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_7);
+lean_dec(x_3);
+x_11 = lean_box(0);
+x_12 = lean_apply_1(x_2, x_11);
+return x_12;
+}
+}
+}
+}
+lean_object* l_System_FilePath_fileStem_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_System_FilePath_fileStem_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+lean_object* l_System_FilePath_fileStem(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_System_FilePath_fileName(x_1);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
+}
+else
+{
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_2);
+if (x_4 == 0)
+{
+lean_object* x_5; uint32_t x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = 46;
+x_7 = l_String_revPosOf(x_5, x_6);
+if (lean_obj_tag(x_7) == 0)
+{
+return x_2;
+}
+else
+{
+uint8_t x_8; 
+lean_free_object(x_2);
+x_8 = !lean_is_exclusive(x_7);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; uint8_t x_11; 
+x_9 = lean_ctor_get(x_7, 0);
+x_10 = lean_unsigned_to_nat(0u);
+x_11 = lean_nat_dec_eq(x_9, x_10);
+if (x_11 == 0)
+{
+lean_object* x_12; 
+x_12 = lean_string_utf8_extract(x_5, x_10, x_9);
+lean_dec(x_9);
+lean_dec(x_5);
+lean_ctor_set(x_7, 0, x_12);
+return x_7;
+}
+else
+{
+lean_dec(x_9);
+lean_ctor_set(x_7, 0, x_5);
+return x_7;
+}
+}
+else
+{
+lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_13 = lean_ctor_get(x_7, 0);
+lean_inc(x_13);
+lean_dec(x_7);
+x_14 = lean_unsigned_to_nat(0u);
+x_15 = lean_nat_dec_eq(x_13, x_14);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; 
+x_16 = lean_string_utf8_extract(x_5, x_14, x_13);
+lean_dec(x_13);
+lean_dec(x_5);
+x_17 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_17, 0, x_16);
+return x_17;
+}
+else
+{
+lean_object* x_18; 
+lean_dec(x_13);
+x_18 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_18, 0, x_5);
+return x_18;
+}
+}
+}
+}
+else
+{
+lean_object* x_19; uint32_t x_20; lean_object* x_21; 
+x_19 = lean_ctor_get(x_2, 0);
+lean_inc(x_19);
+lean_dec(x_2);
+x_20 = 46;
+x_21 = l_String_revPosOf(x_19, x_20);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; 
+x_22 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_22, 0, x_19);
+return x_22;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_23 = lean_ctor_get(x_21, 0);
+lean_inc(x_23);
+if (lean_is_exclusive(x_21)) {
+ lean_ctor_release(x_21, 0);
+ x_24 = x_21;
+} else {
+ lean_dec_ref(x_21);
+ x_24 = lean_box(0);
+}
+x_25 = lean_unsigned_to_nat(0u);
+x_26 = lean_nat_dec_eq(x_23, x_25);
+if (x_26 == 0)
+{
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_string_utf8_extract(x_19, x_25, x_23);
+lean_dec(x_23);
+lean_dec(x_19);
+if (lean_is_scalar(x_24)) {
+ x_28 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_28 = x_24;
+}
+lean_ctor_set(x_28, 0, x_27);
+return x_28;
+}
+else
+{
+lean_object* x_29; 
+lean_dec(x_23);
+if (lean_is_scalar(x_24)) {
+ x_29 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_29 = x_24;
+}
+lean_ctor_set(x_29, 0, x_19);
+return x_29;
+}
+}
+}
+}
+}
+}
+lean_object* l_System_FilePath_extension(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_System_FilePath_fileName(x_1);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
+}
+else
+{
+lean_object* x_4; uint32_t x_5; lean_object* x_6; 
+x_4 = lean_ctor_get(x_2, 0);
+lean_inc(x_4);
+lean_dec(x_2);
+x_5 = 46;
+x_6 = l_String_revPosOf(x_4, x_5);
+if (lean_obj_tag(x_6) == 0)
+{
+lean_object* x_7; 
+lean_dec(x_4);
+x_7 = lean_box(0);
+return x_7;
+}
+else
+{
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_6);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; uint8_t x_11; 
+x_9 = lean_ctor_get(x_6, 0);
+x_10 = lean_unsigned_to_nat(0u);
+x_11 = lean_nat_dec_eq(x_9, x_10);
+if (x_11 == 0)
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_12 = lean_unsigned_to_nat(1u);
+x_13 = lean_nat_add(x_9, x_12);
+lean_dec(x_9);
+x_14 = lean_string_utf8_byte_size(x_4);
+x_15 = lean_string_utf8_extract(x_4, x_13, x_14);
+lean_dec(x_14);
+lean_dec(x_13);
+lean_dec(x_4);
+lean_ctor_set(x_6, 0, x_15);
+return x_6;
+}
+else
+{
+lean_object* x_16; 
+lean_free_object(x_6);
+lean_dec(x_9);
+lean_dec(x_4);
+x_16 = lean_box(0);
+return x_16;
+}
+}
+else
+{
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_6, 0);
+lean_inc(x_17);
+lean_dec(x_6);
+x_18 = lean_unsigned_to_nat(0u);
+x_19 = lean_nat_dec_eq(x_17, x_18);
+if (x_19 == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_20 = lean_unsigned_to_nat(1u);
+x_21 = lean_nat_add(x_17, x_20);
+lean_dec(x_17);
+x_22 = lean_string_utf8_byte_size(x_4);
+x_23 = lean_string_utf8_extract(x_4, x_21, x_22);
+lean_dec(x_22);
+lean_dec(x_21);
+lean_dec(x_4);
+x_24 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_24, 0, x_23);
+return x_24;
+}
+else
+{
+lean_object* x_25; 
+lean_dec(x_17);
+lean_dec(x_4);
+x_25 = lean_box(0);
+return x_25;
+}
+}
+}
+}
+}
+}
+lean_object* l_System_FilePath_withFileName_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_System_FilePath_withFileName_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_System_FilePath_withFileName_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_System_FilePath_withFileName(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_parent(x_1);
+if (lean_obj_tag(x_3) == 0)
+{
+lean_inc(x_2);
+return x_2;
+}
+else
+{
+lean_object* x_4; lean_object* x_5; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+lean_dec(x_3);
+x_5 = l_System_FilePath_join(x_4, x_2);
+return x_5;
+}
+}
+}
+lean_object* l_System_FilePath_withFileName___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_withFileName(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_withExtension_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_System_FilePath_withExtension_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_System_FilePath_withExtension_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_System_FilePath_withExtension(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+lean_inc(x_1);
+x_3 = l_System_FilePath_fileStem(x_1);
+if (lean_obj_tag(x_3) == 0)
+{
+return x_1;
+}
+else
+{
+lean_object* x_4; uint8_t x_5; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+lean_dec(x_3);
+x_5 = l_String_isEmpty(x_2);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_6 = l_Lean_Parser_Tactic_tactic_xb7_x2e_____closed__5;
+x_7 = lean_string_append(x_4, x_6);
+x_8 = lean_string_append(x_7, x_2);
+x_9 = l_System_FilePath_withFileName(x_1, x_8);
+lean_dec(x_8);
+lean_dec(x_1);
+return x_9;
+}
+else
+{
+lean_object* x_10; 
+x_10 = l_System_FilePath_withFileName(x_1, x_4);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+}
+}
+}
+lean_object* l_System_FilePath_withExtension___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_withExtension(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_components(lean_object* x_1) {
+_start:
+{
+uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_2 = 0;
+x_3 = l_System_FilePath_normalize(x_1, x_2);
+x_4 = l_System_FilePath_join___closed__1;
+x_5 = l_String_splitOn(x_3, x_4);
+return x_5;
+}
+}
+lean_object* l_System_mkFilePath(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_System_FilePath_join___closed__1;
+x_3 = l_String_intercalate(x_2, x_1);
+return x_3;
+}
+}
+lean_object* l_System_instCoeStringFilePath(lean_object* x_1) {
+_start:
+{
+lean_inc(x_1);
+return x_1;
+}
+}
+lean_object* l_System_instCoeStringFilePath___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_System_instCoeStringFilePath(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
+static uint32_t _init_l_System_SearchPath_separator___closed__1() {
 _start:
 {
 uint8_t x_1; 
@@ -178,15 +1529,15 @@ return x_3;
 }
 }
 }
-static uint32_t _init_l_System_FilePath_searchPathSeparator() {
+static uint32_t _init_l_System_SearchPath_separator() {
 _start:
 {
 uint32_t x_1; 
-x_1 = l_System_FilePath_searchPathSeparator___closed__1;
+x_1 = l_System_SearchPath_separator___closed__1;
 return x_1;
 }
 }
-lean_object* l_String_splitAux___at_System_FilePath_splitSearchPath___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_String_splitAux___at_System_SearchPath_parse___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -195,7 +1546,7 @@ if (x_5 == 0)
 {
 uint32_t x_6; uint32_t x_7; uint8_t x_8; 
 x_6 = lean_string_utf8_get(x_1, x_3);
-x_7 = l_System_FilePath_searchPathSeparator;
+x_7 = l_System_SearchPath_separator;
 x_8 = x_7 == x_6;
 if (x_8 == 0)
 {
@@ -239,410 +1590,152 @@ return x_19;
 }
 }
 }
-lean_object* l_String_split___at_System_FilePath_splitSearchPath___spec__1(lean_object* x_1) {
+lean_object* l_String_split___at_System_SearchPath_parse___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = lean_box(0);
 x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_String_splitAux___at_System_FilePath_splitSearchPath___spec__2(x_1, x_3, x_3, x_2);
+x_4 = l_String_splitAux___at_System_SearchPath_parse___spec__2(x_1, x_3, x_3, x_2);
 return x_4;
 }
 }
-lean_object* l_System_FilePath_splitSearchPath(lean_object* x_1) {
+lean_object* l_List_map___at_System_SearchPath_parse___spec__3(lean_object* x_1) {
 _start:
 {
+if (lean_obj_tag(x_1) == 0)
+{
 lean_object* x_2; 
-x_2 = l_String_split___at_System_FilePath_splitSearchPath___spec__1(x_1);
-return x_2;
-}
-}
-lean_object* l_String_splitAux___at_System_FilePath_splitSearchPath___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_String_splitAux___at_System_FilePath_splitSearchPath___spec__2(x_1, x_2, x_3, x_4);
-lean_dec(x_1);
-return x_5;
-}
-}
-lean_object* l_String_split___at_System_FilePath_splitSearchPath___spec__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_String_split___at_System_FilePath_splitSearchPath___spec__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_System_FilePath_splitSearchPath___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_System_FilePath_splitSearchPath(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-static uint32_t _init_l_System_FilePath_extSeparator() {
-_start:
-{
-uint32_t x_1; 
-x_1 = 46;
-return x_1;
-}
-}
-static lean_object* _init_l_System_FilePath_exeSuffix___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string(".exe");
-return x_1;
-}
-}
-static lean_object* _init_l_System_FilePath_exeSuffix___closed__2() {
-_start:
-{
-uint8_t x_1; 
-x_1 = l_System_Platform_isWindows;
-if (x_1 == 0)
-{
-lean_object* x_2; 
-x_2 = l_Lean_instInhabitedParserDescr___closed__1;
-return x_2;
-}
-else
-{
-lean_object* x_3; 
-x_3 = l_System_FilePath_exeSuffix___closed__1;
-return x_3;
-}
-}
-}
-static lean_object* _init_l_System_FilePath_exeSuffix() {
-_start:
-{
-lean_object* x_1; 
-x_1 = l_System_FilePath_exeSuffix___closed__2;
-return x_1;
-}
-}
-static uint8_t _init_l_System_FilePath_isCaseInsensitive___closed__1() {
-_start:
-{
-uint8_t x_1; 
-x_1 = l_System_Platform_isWindows;
-if (x_1 == 0)
-{
-uint8_t x_2; 
-x_2 = l_System_Platform_isOSX;
+x_2 = lean_box(0);
 return x_2;
 }
 else
 {
 uint8_t x_3; 
-x_3 = 1;
-return x_3;
-}
-}
-}
-static uint8_t _init_l_System_FilePath_isCaseInsensitive() {
-_start:
+x_3 = !lean_is_exclusive(x_1);
+if (x_3 == 0)
 {
-uint8_t x_1; 
-x_1 = l_System_FilePath_isCaseInsensitive___closed__1;
+lean_object* x_4; lean_object* x_5; 
+x_4 = lean_ctor_get(x_1, 1);
+x_5 = l_List_map___at_System_SearchPath_parse___spec__3(x_4);
+lean_ctor_set(x_1, 1, x_5);
 return x_1;
 }
-}
-uint8_t l_List_foldr___at_System_FilePath_normalizePath___spec__1(uint32_t x_1, uint8_t x_2, lean_object* x_3) {
-_start:
-{
-if (lean_obj_tag(x_3) == 0)
-{
-return x_2;
-}
 else
 {
-lean_object* x_4; lean_object* x_5; uint8_t x_6; uint32_t x_7; uint8_t x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-lean_dec(x_3);
-x_6 = l_List_foldr___at_System_FilePath_normalizePath___spec__1(x_1, x_2, x_5);
-x_7 = lean_unbox_uint32(x_4);
-lean_dec(x_4);
-x_8 = x_1 == x_7;
-if (x_8 == 0)
-{
-return x_6;
-}
-else
-{
-uint8_t x_9; 
-x_9 = 1;
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_6 = lean_ctor_get(x_1, 0);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_dec(x_1);
+x_8 = l_List_map___at_System_SearchPath_parse___spec__3(x_7);
+x_9 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_9, 0, x_6);
+lean_ctor_set(x_9, 1, x_8);
 return x_9;
 }
 }
 }
 }
-lean_object* l_String_mapAux___at_System_FilePath_normalizePath___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_System_SearchPath_parse(lean_object* x_1) {
 _start:
 {
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_String_split___at_System_SearchPath_parse___spec__1(x_1);
+x_3 = l_List_map___at_System_SearchPath_parse___spec__3(x_2);
+return x_3;
+}
+}
+lean_object* l_String_splitAux___at_System_SearchPath_parse___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_String_splitAux___at_System_SearchPath_parse___spec__2(x_1, x_2, x_3, x_4);
+lean_dec(x_1);
+return x_5;
+}
+}
+lean_object* l_String_split___at_System_SearchPath_parse___spec__1___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_String_split___at_System_SearchPath_parse___spec__1(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
+lean_object* l_System_SearchPath_parse___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_System_SearchPath_parse(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
+lean_object* l_List_map___at_System_SearchPath_toString___spec__1(lean_object* x_1) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_2; 
+x_2 = lean_box(0);
+return x_2;
+}
+else
+{
 uint8_t x_3; 
-x_3 = lean_string_utf8_at_end(x_2, x_1);
+x_3 = !lean_is_exclusive(x_1);
 if (x_3 == 0)
 {
-uint32_t x_4; uint8_t x_5; lean_object* x_6; uint8_t x_7; 
-x_4 = lean_string_utf8_get(x_2, x_1);
-x_5 = 0;
-x_6 = l_System_FilePath_pathSeparators;
-x_7 = l_List_foldr___at_System_FilePath_normalizePath___spec__1(x_4, x_5, x_6);
-if (x_7 == 0)
+lean_object* x_4; lean_object* x_5; 
+x_4 = lean_ctor_get(x_1, 1);
+x_5 = l_List_map___at_System_SearchPath_toString___spec__1(x_4);
+lean_ctor_set(x_1, 1, x_5);
+return x_1;
+}
+else
 {
-lean_object* x_8; lean_object* x_9; 
-x_8 = lean_string_utf8_set(x_2, x_1, x_4);
-x_9 = lean_string_utf8_next(x_8, x_1);
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_6 = lean_ctor_get(x_1, 0);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_inc(x_6);
 lean_dec(x_1);
-x_1 = x_9;
-x_2 = x_8;
-goto _start;
-}
-else
-{
-uint32_t x_11; lean_object* x_12; lean_object* x_13; 
-x_11 = l_System_FilePath_pathSeparator;
-x_12 = lean_string_utf8_set(x_2, x_1, x_11);
-x_13 = lean_string_utf8_next(x_12, x_1);
-lean_dec(x_1);
-x_1 = x_13;
-x_2 = x_12;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_1);
-return x_2;
-}
-}
-}
-uint8_t l_List_foldr___at_System_FilePath_normalizePath___spec__3(uint32_t x_1, uint8_t x_2, lean_object* x_3) {
-_start:
-{
-if (lean_obj_tag(x_3) == 0)
-{
-return x_2;
-}
-else
-{
-lean_object* x_4; lean_object* x_5; uint8_t x_6; uint32_t x_7; uint8_t x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-lean_dec(x_3);
-x_6 = l_List_foldr___at_System_FilePath_normalizePath___spec__3(x_1, x_2, x_5);
-x_7 = lean_unbox_uint32(x_4);
-lean_dec(x_4);
-x_8 = x_1 == x_7;
-if (x_8 == 0)
-{
-return x_6;
-}
-else
-{
-uint8_t x_9; 
-x_9 = 1;
+x_8 = l_List_map___at_System_SearchPath_toString___spec__1(x_7);
+x_9 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_9, 0, x_6);
+lean_ctor_set(x_9, 1, x_8);
 return x_9;
 }
 }
 }
 }
-lean_object* l_String_mapAux___at_System_FilePath_normalizePath___spec__4(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = lean_string_utf8_at_end(x_2, x_1);
-if (x_3 == 0)
-{
-uint32_t x_4; uint8_t x_5; lean_object* x_6; uint8_t x_7; 
-x_4 = lean_string_utf8_get(x_2, x_1);
-x_5 = 0;
-x_6 = l_System_FilePath_pathSeparators;
-x_7 = l_List_foldr___at_System_FilePath_normalizePath___spec__3(x_4, x_5, x_6);
-if (x_7 == 0)
-{
-lean_object* x_8; lean_object* x_9; 
-x_8 = lean_string_utf8_set(x_2, x_1, x_4);
-x_9 = lean_string_utf8_next(x_8, x_1);
-lean_dec(x_1);
-x_1 = x_9;
-x_2 = x_8;
-goto _start;
-}
-else
-{
-uint32_t x_11; lean_object* x_12; lean_object* x_13; 
-x_11 = l_System_FilePath_pathSeparator;
-x_12 = lean_string_utf8_set(x_2, x_1, x_11);
-x_13 = lean_string_utf8_next(x_12, x_1);
-lean_dec(x_1);
-x_1 = x_13;
-x_2 = x_12;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_1);
-return x_2;
-}
-}
-}
-static lean_object* _init_l_System_FilePath_normalizePath___closed__1() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_System_FilePath_pathSeparators;
-x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_List_lengthAux___rarg(x_1, x_2);
-return x_3;
-}
-}
-static uint8_t _init_l_System_FilePath_normalizePath___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; uint8_t x_3; 
-x_1 = l_System_FilePath_normalizePath___closed__1;
-x_2 = lean_unsigned_to_nat(1u);
-x_3 = lean_nat_dec_eq(x_1, x_2);
-return x_3;
-}
-}
-lean_object* l_System_FilePath_normalizePath(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; 
-x_2 = l_System_FilePath_normalizePath___closed__2;
-if (x_2 == 0)
-{
-lean_object* x_3; lean_object* x_4; 
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_String_mapAux___at_System_FilePath_normalizePath___spec__2(x_3, x_1);
-return x_4;
-}
-else
-{
-uint8_t x_5; 
-x_5 = l_System_FilePath_isCaseInsensitive;
-if (x_5 == 0)
-{
-return x_1;
-}
-else
-{
-lean_object* x_6; lean_object* x_7; 
-x_6 = lean_unsigned_to_nat(0u);
-x_7 = l_String_mapAux___at_System_FilePath_normalizePath___spec__4(x_6, x_1);
-return x_7;
-}
-}
-}
-}
-lean_object* l_List_foldr___at_System_FilePath_normalizePath___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint32_t x_4; uint8_t x_5; uint8_t x_6; lean_object* x_7; 
-x_4 = lean_unbox_uint32(x_1);
-lean_dec(x_1);
-x_5 = lean_unbox(x_2);
-lean_dec(x_2);
-x_6 = l_List_foldr___at_System_FilePath_normalizePath___spec__1(x_4, x_5, x_3);
-x_7 = lean_box(x_6);
-return x_7;
-}
-}
-lean_object* l_List_foldr___at_System_FilePath_normalizePath___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint32_t x_4; uint8_t x_5; uint8_t x_6; lean_object* x_7; 
-x_4 = lean_unbox_uint32(x_1);
-lean_dec(x_1);
-x_5 = lean_unbox(x_2);
-lean_dec(x_2);
-x_6 = l_List_foldr___at_System_FilePath_normalizePath___spec__3(x_4, x_5, x_3);
-x_7 = lean_box(x_6);
-return x_7;
-}
-}
-lean_object* l_System_FilePath_parent(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; uint32_t x_3; lean_object* x_4; 
-x_2 = l_System_FilePath_normalizePath(x_1);
-x_3 = l_System_FilePath_pathSeparator;
-x_4 = l_String_revPosOf(x_2, x_3);
-if (lean_obj_tag(x_4) == 0)
-{
-lean_object* x_5; 
-lean_dec(x_2);
-x_5 = lean_box(0);
-return x_5;
-}
-else
-{
-uint8_t x_6; 
-x_6 = !lean_is_exclusive(x_4);
-if (x_6 == 0)
-{
-lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_7 = lean_ctor_get(x_4, 0);
-x_8 = lean_unsigned_to_nat(0u);
-x_9 = lean_string_utf8_extract(x_2, x_8, x_7);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_ctor_set(x_4, 0, x_9);
-return x_4;
-}
-else
-{
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_10 = lean_ctor_get(x_4, 0);
-lean_inc(x_10);
-lean_dec(x_4);
-x_11 = lean_unsigned_to_nat(0u);
-x_12 = lean_string_utf8_extract(x_2, x_11, x_10);
-lean_dec(x_10);
-lean_dec(x_2);
-x_13 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_13, 0, x_12);
-return x_13;
-}
-}
-}
-}
-static lean_object* _init_l_System_mkFilePath___closed__1() {
+static lean_object* _init_l_System_SearchPath_toString___closed__1() {
 _start:
 {
 lean_object* x_1; uint32_t x_2; lean_object* x_3; 
 x_1 = l_Lean_instInhabitedParserDescr___closed__1;
-x_2 = l_System_FilePath_pathSeparator;
+x_2 = l_System_SearchPath_separator;
 x_3 = lean_string_push(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_System_mkFilePath(lean_object* x_1) {
+lean_object* l_System_SearchPath_toString(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; lean_object* x_3; 
-x_2 = l_System_mkFilePath___closed__1;
-x_3 = l_String_intercalate(x_2, x_1);
-return x_3;
+lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_2 = l_List_map___at_System_SearchPath_toString___spec__1(x_1);
+x_3 = l_System_SearchPath_toString___closed__1;
+x_4 = l_String_intercalate(x_3, x_2);
+return x_4;
 }
 }
 lean_object* initialize_Init_System_Platform(lean_object*);
 lean_object* initialize_Init_Data_String_Basic(lean_object*);
+lean_object* initialize_Init_Data_Repr(lean_object*);
+lean_object* initialize_Init_Data_ToString_Basic(lean_object*);
 static bool _G_initialized = false;
 lean_object* initialize_Init_System_FilePath(lean_object* w) {
 lean_object * res;
@@ -654,6 +1747,18 @@ lean_dec_ref(res);
 res = initialize_Init_Data_String_Basic(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Init_Data_Repr(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Init_Data_ToString_Basic(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+l_System_instInhabitedFilePath = _init_l_System_instInhabitedFilePath();
+lean_mark_persistent(l_System_instInhabitedFilePath);
+l_System_instReprFilePath___closed__1 = _init_l_System_instReprFilePath___closed__1();
+lean_mark_persistent(l_System_instReprFilePath___closed__1);
+l_System_instReprFilePath___closed__2 = _init_l_System_instReprFilePath___closed__2();
+lean_mark_persistent(l_System_instReprFilePath___closed__2);
 l_System_FilePath_pathSeparator___closed__1 = _init_l_System_FilePath_pathSeparator___closed__1();
 l_System_FilePath_pathSeparator = _init_l_System_FilePath_pathSeparator();
 l_System_FilePath_pathSeparators___closed__1___boxed__const__1 = _init_l_System_FilePath_pathSeparators___closed__1___boxed__const__1();
@@ -668,22 +1773,32 @@ l_System_FilePath_pathSeparators___closed__3 = _init_l_System_FilePath_pathSepar
 lean_mark_persistent(l_System_FilePath_pathSeparators___closed__3);
 l_System_FilePath_pathSeparators = _init_l_System_FilePath_pathSeparators();
 lean_mark_persistent(l_System_FilePath_pathSeparators);
-l_System_FilePath_searchPathSeparator___closed__1 = _init_l_System_FilePath_searchPathSeparator___closed__1();
-l_System_FilePath_searchPathSeparator = _init_l_System_FilePath_searchPathSeparator();
 l_System_FilePath_extSeparator = _init_l_System_FilePath_extSeparator();
-l_System_FilePath_exeSuffix___closed__1 = _init_l_System_FilePath_exeSuffix___closed__1();
-lean_mark_persistent(l_System_FilePath_exeSuffix___closed__1);
-l_System_FilePath_exeSuffix___closed__2 = _init_l_System_FilePath_exeSuffix___closed__2();
-lean_mark_persistent(l_System_FilePath_exeSuffix___closed__2);
-l_System_FilePath_exeSuffix = _init_l_System_FilePath_exeSuffix();
-lean_mark_persistent(l_System_FilePath_exeSuffix);
+l_System_FilePath_exeExtension___closed__1 = _init_l_System_FilePath_exeExtension___closed__1();
+lean_mark_persistent(l_System_FilePath_exeExtension___closed__1);
+l_System_FilePath_exeExtension___closed__2 = _init_l_System_FilePath_exeExtension___closed__2();
+lean_mark_persistent(l_System_FilePath_exeExtension___closed__2);
+l_System_FilePath_exeExtension = _init_l_System_FilePath_exeExtension();
+lean_mark_persistent(l_System_FilePath_exeExtension);
 l_System_FilePath_isCaseInsensitive___closed__1 = _init_l_System_FilePath_isCaseInsensitive___closed__1();
 l_System_FilePath_isCaseInsensitive = _init_l_System_FilePath_isCaseInsensitive();
-l_System_FilePath_normalizePath___closed__1 = _init_l_System_FilePath_normalizePath___closed__1();
-lean_mark_persistent(l_System_FilePath_normalizePath___closed__1);
-l_System_FilePath_normalizePath___closed__2 = _init_l_System_FilePath_normalizePath___closed__2();
-l_System_mkFilePath___closed__1 = _init_l_System_mkFilePath___closed__1();
-lean_mark_persistent(l_System_mkFilePath___closed__1);
+l_System_FilePath_normalize___closed__1 = _init_l_System_FilePath_normalize___closed__1();
+lean_mark_persistent(l_System_FilePath_normalize___closed__1);
+l_System_FilePath_normalize___closed__2 = _init_l_System_FilePath_normalize___closed__2();
+l_System_FilePath_join___closed__1 = _init_l_System_FilePath_join___closed__1();
+lean_mark_persistent(l_System_FilePath_join___closed__1);
+l_System_FilePath_instDivFilePath___closed__1 = _init_l_System_FilePath_instDivFilePath___closed__1();
+lean_mark_persistent(l_System_FilePath_instDivFilePath___closed__1);
+l_System_FilePath_instDivFilePath = _init_l_System_FilePath_instDivFilePath();
+lean_mark_persistent(l_System_FilePath_instDivFilePath);
+l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___closed__1 = _init_l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___closed__1();
+lean_mark_persistent(l___private_Init_System_FilePath_0__System_FilePath_posOfLastSep___closed__1);
+l_System_FilePath_fileName___closed__1 = _init_l_System_FilePath_fileName___closed__1();
+lean_mark_persistent(l_System_FilePath_fileName___closed__1);
+l_System_SearchPath_separator___closed__1 = _init_l_System_SearchPath_separator___closed__1();
+l_System_SearchPath_separator = _init_l_System_SearchPath_separator();
+l_System_SearchPath_toString___closed__1 = _init_l_System_SearchPath_toString___closed__1();
+lean_mark_persistent(l_System_SearchPath_toString___closed__1);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Init/System/IO.c b/stage0/stdlib/Init/System/IO.c
index 35240f02fb..a3306e4942 100644
--- a/stage0/stdlib/Init/System/IO.c
+++ b/stage0/stdlib/Init/System/IO.c
@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Init.System.IO
-// Imports: Init.Control.EState Init.Control.Reader Init.Data.String Init.Data.ByteArray Init.System.IOError Init.System.FilePath Init.System.ST Init.Data.ToString.Macro
+// Imports: Init.Control.EState Init.Control.Reader Init.Data.String Init.Data.ByteArray Init.System.IOError Init.System.FilePath Init.System.ST Init.Data.ToString.Macro Init.Data.Ord
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -13,28 +13,40 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_List_reverse___rarg(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__21;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__6;
 lean_object* lean_string_push(lean_object*, uint32_t);
 lean_object* l_IO_cancel___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_Buffer_pos___default;
 lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_readBinToEnd_loop___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
+lean_object* l_IO_FS_instReprMetadata___closed__1;
 lean_object* l_IO_getStdin___rarg___closed__1;
 lean_object* l_MonadExcept_orelse___at_instOrElseEIO___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_putStrLn___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9;
 lean_object* l_IO_getStdout(lean_object*);
 lean_object* lean_io_get_num_heartbeats(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952_(lean_object*, lean_object*);
 lean_object* l_IO_FS_withIsolatedStreams___rarg(lean_object*, lean_object*);
+lean_object* l_IO_createDirAll___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_allocprof___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_instEvalUnit___rarg(uint8_t, lean_object*);
+lean_object* l_System_FilePath_isDir___boxed(lean_object*, lean_object*);
 lean_object* l_IO_mkRef___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_get_stdin(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__4;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__8;
 extern uint8_t l_System_Platform_isWindows;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__4;
 lean_object* l_IO_appPath___rarg___closed__1;
 lean_object* lean_io_prim_handle_get_line(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_readToEnd_read___at_IO_Process_output___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_mono_ms_now(lean_object*);
 lean_object* lean_io_timeit(lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_prim_handle_is_eof(lean_object*, lean_object*);
+lean_object* l_System_FilePath_join(lean_object*, lean_object*);
 lean_object* lean_get_set_stdout(lean_object*, lean_object*);
 lean_object* lean_chmod(lean_object*, uint32_t, lean_object*);
 lean_object* l_instMonadEIO(lean_object*);
@@ -45,10 +57,11 @@ extern lean_object* l_Char_quote___closed__1;
 lean_object* l_IO_Prim_getEnv___boxed(lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_wait_any(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1___rarg(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_IO_bindTask___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_error_to_string(lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__1;
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_println(lean_object*);
 lean_object* l_IO_Prim_fopenFlags_match__1(lean_object*);
@@ -57,11 +70,15 @@ lean_object* l_IO_Prim_getStderr___boxed(lean_object*);
 lean_object* l_IO_Prim_fopenFlags___closed__12;
 lean_object* l_MonadExcept_orelse___at_instOrElseEIO___spec__1(lean_object*, lean_object*);
 lean_object* l_IO_hasFinished___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofHandle___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_Format_defWidth;
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_setStdout___at_IO_FS_withIsolatedStreams___spec__6(lean_object*, lean_object*);
 lean_object* l_IO_FS_withFile___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
-lean_object* lean_io_is_dir(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__1;
+uint8_t l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097_(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____boxed(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_putStr___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_instMonadFinallyEIO(lean_object*);
 lean_object* l_IO_instMonadLiftSTRealWorldEIO_match__2(lean_object*, lean_object*);
@@ -71,19 +88,24 @@ lean_object* lean_io_cancel(lean_object*, lean_object*);
 lean_object* l_Lean_instEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_lines_read___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_putStrLn___rarg(lean_object*, lean_object*, lean_object*);
+uint8_t l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016_(lean_object*, lean_object*);
 lean_object* l_EStateM_tryCatch___at_IO_FS_withIsolatedStreams___spec__2___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 lean_object* lean_io_prim_handle_put_str(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_waitAny___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_getEnv___rarg(lean_object*, lean_object*);
 lean_object* l_IO_FileRight_user___default___closed__1;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__7;
+extern lean_object* l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__4;
 lean_object* l_IO_appDir___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_instEval___rarg(lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_IO_toEIO(lean_object*, lean_object*);
 extern lean_object* l_termS_x21_____closed__7;
 lean_object* l_IO_FS_Handle_getLine___rarg(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__10;
 extern lean_object* l_Array_empty___closed__1;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__12;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__4;
+extern lean_object* l_System_instReprFilePath___closed__2;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__9;
 lean_object* l_Lean_instEvalIO___rarg(lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_IO_Prim_getStdout___boxed(lean_object*);
 lean_object* l_IO_removeFile___rarg(lean_object*, lean_object*);
@@ -97,10 +119,12 @@ lean_object* lean_get_stderr(lean_object*);
 uint32_t l_UInt32_shiftLeft(uint32_t, uint32_t);
 uint8_t lean_name_eq(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_write(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1(lean_object*);
 lean_object* l_IO_print(lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__5(lean_object*);
 extern lean_object* l_termS_x21_____closed__3;
 lean_object* l_Lean_instEvalUnit(lean_object*);
+lean_object* l_IO_FS_instInhabitedSystemTime;
 lean_object* l_IO_FS_Handle_flush___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_instEvalUnit___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_ST_Prim_mkRef___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -113,66 +137,93 @@ lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* l_IO_withStderr___at_IO_FS_withIsolatedStreams___spec__3(lean_object*);
 lean_object* l_termPrintln_x21_______closed__6;
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_IO_FS_instReprSystemTime___closed__1;
 extern lean_object* l_Lean_interpolatedStrKind;
 lean_object* l_IO_Process_SpawnArgs_args___default;
 uint32_t l_IO_AccessRight_flags___closed__6;
 lean_object* l_IO_FS_Handle_readToEnd___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__1;
 lean_object* l_IO_ofExcept_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_instMonadLiftSTRealWorldEIO_match__1___boxed(lean_object*, lean_object*);
-lean_object* l_IO_isDir(lean_object*);
 lean_object* l_IO_FS_Handle_readBinToEnd_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_sleep(uint32_t, lean_object*);
 lean_object* l_IO_monoMsNow___boxed(lean_object*);
 lean_object* l_IO_FS_readBinFile(lean_object*);
 lean_object* l_IO_Prim_setStdout___boxed(lean_object*, lean_object*);
+lean_object* l_IO_FS_instBEqFileType;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
 lean_object* l_EIO_catchExceptions_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_withIsolatedStreams___rarg___closed__3;
 lean_object* l_IO_Prim_setStderr___boxed(lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags___closed__11;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____boxed(lean_object*, lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_Lean_instEval(lean_object*);
 lean_object* l_IO_FS_lines___rarg(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_instReprProd___rarg___closed__1;
 lean_object* lean_io_process_spawn(lean_object*, lean_object*);
 lean_object* lean_io_getenv(lean_object*, lean_object*);
 uint32_t l_IO_AccessRight_flags___closed__13;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__19;
 lean_object* l_IO_Process_SpawnArgs_cwd___default;
 lean_object* l_Lean_instEvalUnit___boxed(lean_object*);
 lean_object* l_IO_instMonadLiftSTRealWorldEIO_match__1(lean_object*, uint8_t);
 lean_object* l_Lean_instEval__1(lean_object*);
+lean_object* l_IO_createDirAll___boxed(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_getLine___at_IO_Process_output___spec__2(lean_object*, lean_object*);
 lean_object* l_IO_setAccessRights(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__2;
 lean_object* l_IO_setStdout(lean_object*);
 lean_object* l_IO_withStdin(lean_object*);
 lean_object* lean_io_map_task(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_eprintln(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__14;
 extern lean_object* l_termS_x21_____closed__2;
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___lambda__1(lean_object*, lean_object*);
 lean_object* l_IO_withStdin___at_IO_FS_withIsolatedStreams___spec__7(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__18;
+lean_object* l_IO_createDirAll(lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofHandle___elambda__5(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__5;
 lean_object* l_IO_Prim_Handle_isEof___boxed(lean_object*, lean_object*);
 lean_object* l_IO_instMonadLiftSTRealWorldEIO(lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__23;
 lean_object* l_IO_FS_Stream_ofHandle___elambda__4___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* lean_io_create_dir(lean_object*, lean_object*);
 lean_object* l_IO_setStderr(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__3;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_1997____closed__4;
+lean_object* l_IO_FS_instInhabitedSystemTime___closed__1;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__5;
 lean_object* lean_io_bind_task(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_pathExists(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_readBinToEnd_loop___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__29;
+lean_object* l_IO_FS_instReprMetadata;
+lean_object* l_IO_createDirAll___lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_termPrintln_x21_______closed__5;
 lean_object* l_IO_eprint___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_getStderr___at_IO_eprint___spec__1(lean_object*);
 uint32_t l_IO_AccessRight_flags___closed__8;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__6;
+lean_object* l_Int_repr(lean_object*);
 lean_object* l_IO_Prim_fopenFlags___closed__7;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__2;
 lean_object* l_termPrintln_x21_______closed__3;
 lean_object* l_IO_lazyPure___rarg(lean_object*, lean_object*);
 lean_object* l_IO_FS_withIsolatedStreams___rarg___closed__2;
 lean_object* l_IO_FS_withIsolatedStreams___rarg___lambda__1(lean_object*, lean_object*);
 lean_object* lean_io_as_task(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_AccessRight_flags___boxed(lean_object*);
+lean_object* l_IO_mapTasks_go_match__1(lean_object*, lean_object*);
 lean_object* l_IO_Prim_realPath___boxed(lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__2___boxed(lean_object*, lean_object*);
 extern lean_object* l_ByteArray_empty;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280_(lean_object*, lean_object*);
 lean_object* l_IO_appDir(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____boxed(lean_object*, lean_object*);
 lean_object* lean_io_eprintln(lean_object*, lean_object*);
 lean_object* l_EIO_toIO___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Prim_removeFile___boxed(lean_object*, lean_object*);
@@ -180,98 +231,126 @@ uint32_t l_IO_AccessRight_flags___closed__1;
 uint32_t l_IO_AccessRight_flags___closed__9;
 lean_object* l_IO_appPath___rarg(lean_object*);
 lean_object* l_IO_FS_Handle_readBinToEnd(lean_object*);
+lean_object* l_IO_createDirAll___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_IO_sleep___lambda__1(lean_object*, lean_object*);
+extern lean_object* l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__30;
 uint32_t l_IO_AccessRight_flags___closed__2;
 lean_object* l_IO_Process_SpawnArgs_env___default;
+lean_object* l_IO_FS_instLTSystemTime;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__1;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737_(uint8_t, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
+lean_object* l_IO_mapTasks___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_EStateM_bind___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Task_Priority_dedicated;
 lean_object* l_IO_eprintln___at___private_Init_System_IO_0__IO_eprintlnAux___spec__1(lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___lambda__1___boxed(lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__13;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__17;
 lean_object* lean_get_set_stderr(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_read___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_withStdout___at_IO_FS_withIsolatedStreams___spec__5___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__12;
+lean_object* lean_io_read_dir(lean_object*, lean_object*);
 uint32_t l_IO_AccessRight_flags___closed__4;
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_getStderr___rarg___closed__1;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__8;
 lean_object* lean_io_current_dir(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__6;
 lean_object* l_IO_Prim_fopenFlags___closed__10;
 lean_object* l_ByteArray_extract(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_from_utf8_unchecked(lean_object*);
 lean_object* l_instMonadExceptOfEIO(lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer_match__1(lean_object*);
 lean_object* l_IO_FS_Handle_readBinToEnd_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__9;
 lean_object* l_IO_Process_run___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_termPrintln_x21_______closed__7;
 lean_object* l_IO_FS_Stream_putStrLn(lean_object*);
 lean_object* l_IO_withStderr___at_IO_FS_withIsolatedStreams___spec__3___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_wait(lean_object*, lean_object*);
 lean_object* l_IO_print___at_IO_println___spec__1(lean_object*, lean_object*);
+uint8_t l_UInt32_decLt(uint32_t, uint32_t);
 lean_object* l_IO_FS_Handle_write___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_readToEnd_read___at_IO_Process_output___spec__1(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__8;
+lean_object* l_System_FilePath_readDir___boxed(lean_object*, lean_object*);
 lean_object* l_EStateM_tryCatch___at_IO_FS_withIsolatedStreams___spec__2(lean_object*);
 lean_object* l_IO_getStderr___rarg(lean_object*);
 lean_object* lean_io_realpath(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855____boxed(lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__2;
 lean_object* l_IO_FS_Handle_readBinToEnd_loop___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_getStdout___rarg(lean_object*);
 lean_object* lean_dbg_sleep(uint32_t, lean_object*);
+extern lean_object* l___private_Init_Data_Repr_0__reprSourceInfo____x40_Init_Data_Repr___hyg_1438____closed__4;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__6;
 lean_object* l_IO_FS_writeFile___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_mapTasks(lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags(uint8_t, uint8_t);
 lean_object* l_IO_eprintln___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 lean_object* l_IO_FS_Handle_readToEnd_read___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Process_run___closed__1;
 lean_object* l_IO_FS_writeFile(lean_object*);
+lean_object* l_IO_FS_instBEqSystemTime___closed__1;
 uint32_t l_String_back(lean_object*);
 lean_object* l_IO_Prim_Handle_write___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_allocprof(lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_getLine(lean_object*);
 extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Subarray___hyg_903____closed__1;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
 lean_object* l_IO_getNumHeartbeats___boxed(lean_object*, lean_object*);
 lean_object* l_IO_eprint(lean_object*);
 lean_object* l_EIO_toIO_x27___rarg(lean_object*, lean_object*);
 lean_object* lean_format_pretty(lean_object*, lean_object*);
 lean_object* l_EStateM_instMonadFinallyEStateM(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
 lean_object* l_IO_FS_Stream_ofHandle___elambda__2___boxed(lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__8;
 lean_object* l_IO_initializing___boxed(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__13;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 lean_object* lean_stream_of_handle(lean_object*);
 extern lean_object* l_instMonadExceptOfEST___closed__2;
 lean_object* l_IO_Prim_iterate(lean_object*, lean_object*);
 lean_object* l_IO_Prim_iterate___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_FS_instReprSystemTime;
 lean_object* l_IO_FS_Handle_readBinToEnd___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_byte_array_size(lean_object*);
 lean_object* l_IO_FS_Handle_mk(lean_object*);
 lean_object* l_EIO_toIO(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1(lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__4___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_lines_read(lean_object*);
 lean_object* l_IO_Prim_Handle_getLine___boxed(lean_object*, lean_object*);
 lean_object* l_termPrintln_x21_______closed__2;
+lean_object* l_IO_FS_instReprFileType___closed__1;
 lean_object* l_IO_FS_lines_read___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_mk___rarg(lean_object*, lean_object*, uint8_t, uint8_t);
 lean_object* l_IO_sleep___lambda__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_instMonadEST___closed__1;
 lean_object* l_IO_println___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__9;
 lean_object* l_IO_Process_spawn___boxed(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__3;
 lean_object* l_IO_getStdout___rarg___closed__1;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__15;
 lean_object* l_IO_FS_Stream_ofHandle___elambda__5___boxed(lean_object*, lean_object*);
 lean_object* l_IO_getStdin___rarg(lean_object*);
-lean_object* l_IO_fileExists___rarg(lean_object*, lean_object*);
 extern lean_object* l_instReprUnit___closed__2;
 lean_object* l_IO_FS_Handle_readToEnd_read(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855_(uint8_t, uint8_t);
 lean_object* l_IO_FS_Handle_isEof(lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__7;
 lean_object* l_IO_Process_run___closed__2;
 lean_object* l_IO_realPath___rarg(lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_Buffer_data___default;
 lean_object* l_IO_Prim_fopenFlags___closed__6;
 lean_object* l_IO_Prim_appPath___boxed(lean_object*);
+lean_object* l_IO_FS_instReprDirEntry___closed__1;
 lean_object* l_IO_setStdin___rarg(lean_object*, lean_object*);
 lean_object* l_IO_FileRight_flags___boxed(lean_object*);
 lean_object* l_instInhabitedEIO(lean_object*, lean_object*);
@@ -280,29 +359,33 @@ uint32_t l_IO_AccessRight_flags___closed__11;
 extern lean_object* l_Lean_Parser_Syntax_addPrec___closed__10;
 lean_object* l_IO_FS_Handle_read(lean_object*);
 lean_object* lean_io_has_finished(lean_object*, lean_object*);
+extern uint32_t l_instInhabitedUInt32___closed__1;
 lean_object* l_String_dropRight(lean_object*, lean_object*);
 lean_object* l_EIO_catchExceptions(lean_object*, lean_object*);
 extern lean_object* l_termDepIfThenElse___closed__14;
 lean_object* l_IO_setAccessRights___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+lean_object* l_IO_FS_instBEqSystemTime;
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_IO_appDir_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641_(lean_object*, lean_object*);
 lean_object* l_IO_setStderr___at_IO_FS_withIsolatedStreams___spec__4(lean_object*, lean_object*);
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_setStdout___rarg(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__22;
 lean_object* l_termPrintln_x21____;
 lean_object* l_IO_FS_Stream_ofHandle___elambda__2(lean_object*, lean_object*);
 lean_object* l_IO_Process_run(lean_object*, lean_object*);
 uint8_t l_IO_AccessRight_write___default;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+lean_object* l_IO_FS_DirEntry_path(lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__6(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__4;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__8;
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__2___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__2(lean_object*);
 lean_object* l_IO_ofExcept___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nullKind___closed__2;
-lean_object* l_IO_Prim_fileExists___boxed(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276_(lean_object*, lean_object*, lean_object*);
 uint8_t l_IO_Process_StdioConfig_stdout___default;
+lean_object* l_IO_mapTasks_go(lean_object*, lean_object*);
 lean_object* l_IO_Process_Stdio_toHandleType_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_readToEnd_read___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_realPath(lean_object*);
@@ -312,81 +395,112 @@ lean_object* l_IO_FS_withIsolatedStreams___rarg___closed__1;
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_ofExcept(lean_object*, lean_object*);
 lean_object* l_IO_appDir_match__1(lean_object*);
-lean_object* lean_io_file_exists(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__7;
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 lean_object* lean_io_check_canceled(lean_object*);
 lean_object* l_IO_FS_Stream_ofHandle___elambda__4(lean_object*, size_t, lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__4(lean_object*, size_t, lean_object*);
 lean_object* l_IO_currentDir(lean_object*);
-lean_object* l_IO_Prim_isDir___boxed(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__5;
 lean_object* l_IO_FS_writeBinFile(lean_object*);
 lean_object* l_IO_FS_Handle_putStr(lean_object*);
 lean_object* l_IO_Prim_setAccessRights___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_IO_isDir___rarg(lean_object*, lean_object*);
 lean_object* l_IO_getEnv(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__4;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__5;
 lean_object* l_Lean_instEvalIO___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__3;
 lean_object* l_IO_sleep___boxed(lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofHandle___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeEIO___rarg(lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__2;
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
 lean_object* lean_string_to_utf8(lean_object*);
+lean_object* l_IO_FS_instOrdSystemTime;
 lean_object* l_ByteArray_findIdx_x3f_loop___at_IO_FS_Stream_ofBuffer___elambda__2___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_IO_ofExcept_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_process_child_wait(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__1;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__3;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_String_quote(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__7;
 lean_object* l_IO_lazyPure(lean_object*);
 lean_object* l_IO_setStderr___rarg(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_mk___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_wait___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_FS_instBEqFileType___closed__1;
 lean_object* l_Lean_Syntax_getKind(lean_object*);
 lean_object* l_IO_FS_Stream_ofBuffer___elambda__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Prim_currentDir___boxed(lean_object*);
 lean_object* l_IO_appDir___rarg___lambda__1___closed__1;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__13;
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1(lean_object*);
+lean_object* l_IO_createDirAll___lambda__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags___closed__5;
 lean_object* lean_get_stdout(lean_object*);
 lean_object* l_IO_FS_Stream_ofHandle___elambda__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Prim_iterate_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__10;
+uint8_t lean_int_dec_lt(lean_object*, lean_object*);
 lean_object* l_IO_ofExcept___at_IO_Process_output___spec__3(lean_object*, lean_object*);
+lean_object* l_System_FilePath_pathExists___boxed(lean_object*, lean_object*);
 lean_object* l_IO_withStderr___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_mapTasks_go___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_FS_instReprFileType;
+extern lean_object* l_Int_instInhabitedInt___closed__1;
 lean_object* l_IO_Process_Stdio_toHandleType_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_readFile___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_instMonadFinallyEIO___closed__1;
 lean_object* l_IO_withStdout___at_IO_FS_withIsolatedStreams___spec__5(lean_object*);
 lean_object* l_IO_FileRight_other___default;
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_readToEnd_read___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint32_t l_IO_AccessRight_flags(lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__3;
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1(lean_object*);
 lean_object* l_unsafeIO(lean_object*);
 lean_object* l_IO_appDir___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_metadata___boxed(lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags___closed__3;
 lean_object* l_IO_FS_withIsolatedStreams___rarg___lambda__2(lean_object*, lean_object*);
+lean_object* l_IO_FS_instOrdSystemTime___closed__1;
+lean_object* l_System_FilePath_isDir(lean_object*, lean_object*);
 lean_object* l_IO_withStdin___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__11;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__18;
 lean_object* l_IO_checkCanceled___boxed(lean_object*);
+lean_object* l_IO_FS_instLESystemTime;
 lean_object* l_IO_FileRight_group___default;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__6;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_object* l_IO_toEIO___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_putStrLn(lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__14;
 lean_object* lean_byte_array_copy_slice(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016____boxed(lean_object*, lean_object*);
 lean_object* l_IO_FS_lines___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Process_Stdio_toHandleType_match__1(lean_object*);
 lean_object* l_IO_FS_withIsolatedStreams(lean_object*);
 lean_object* l_IO_println___at_Lean_instEval__1___spec__1(lean_object*, lean_object*);
 lean_object* l_instInhabitedEIO___rarg(lean_object*);
 lean_object* lean_get_set_stdin(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__20;
 lean_object* l_IO_FS_Handle_getLine___at_IO_Process_output___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_EStateM_instInhabitedEStateM___rarg(lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_12862____closed__8;
 lean_object* l_instOrElseEIO(lean_object*, lean_object*);
 lean_object* l_IO_eprint___at_IO_eprintln___spec__1(lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__10;
 lean_object* l_IO_appDir___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_writeFile___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_read___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeEIO(lean_object*, lean_object*);
+lean_object* lean_uint64_to_nat(uint64_t);
 uint32_t l_IO_AccessRight_flags___closed__10;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__15;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_ByteArray_append(lean_object*, lean_object*);
 lean_object* l_IO_asTask___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
@@ -396,37 +510,43 @@ lean_object* lean_io_remove_file(lean_object*, lean_object*);
 uint32_t l_UInt32_lor(uint32_t, uint32_t);
 lean_object* l_IO_Prim_fopenFlags___closed__4;
 lean_object* l_IO_appPath(lean_object*);
+extern lean_object* l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__31;
 lean_object* lean_io_initializing(lean_object*);
 lean_object* l_IO_FS_writeBinFile___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofHandle___elambda__6___boxed(lean_object*, lean_object*);
+lean_object* lean_io_metadata(lean_object*, lean_object*);
 extern lean_object* l_prec_x28___x29___closed__7;
 lean_object* l_IO_withStderr(lean_object*);
 lean_object* l_IO_FS_readFile(lean_object*);
 lean_object* l_IO_Prim_fopenFlags___closed__9;
 lean_object* lean_string_length(lean_object*);
+lean_object* l_IO_mapTasks_go___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_mkRef(lean_object*, lean_object*, lean_object*);
 uint8_t l_IO_Process_StdioConfig_stderr___default;
 uint8_t lean_byte_array_get(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_readBinToEnd_loop(lean_object*);
 lean_object* l_IO_getStderr(lean_object*);
+lean_object* l_IO_createDir___boxed(lean_object*, lean_object*);
 lean_object* l_IO_println___at_Lean_instEval___spec__1(lean_object*, lean_object*);
 uint8_t l_IO_Process_StdioConfig_stdin___default;
 extern lean_object* l_prec_x28___x29___closed__3;
 lean_object* l_System_FilePath_parent(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__16;
 lean_object* l_IO_Prim_fopenFlags___closed__8;
 lean_object* l_IO_Prim_Handle_putStr___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 lean_object* l_IO_withStdout(lean_object*);
 lean_object* l_timeit___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_app_dir(lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__6;
 extern lean_object* l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__2;
 lean_object* l_IO_FS_Handle_isEof___rarg(lean_object*, lean_object*);
 lean_object* l_IO_FS_Handle_flush(lean_object*);
 uint32_t l_IO_AccessRight_flags___closed__12;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__4;
 lean_object* l_IO_Prim_fopenFlags___boxed(lean_object*, lean_object*);
 lean_object* l_IO_mkRef___rarg(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__12;
 lean_object* l_IO_getStdin(lean_object*);
 lean_object* l_IO_mapTask___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_ofHandle___elambda__6(lean_object*, lean_object*);
@@ -439,31 +559,35 @@ lean_object* lean_io_prim_handle_read(lean_object*, size_t, lean_object*);
 lean_object* l_IO_instMonadLiftSTRealWorldEIO___rarg(lean_object*, lean_object*);
 lean_object* lean_usize_to_nat(size_t);
 lean_object* l_Lean_instEval__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t lean_int_dec_eq(lean_object*, lean_object*);
 lean_object* l_IO_FS_lines(lean_object*);
-lean_object* l_IO_fileExists(lean_object*);
 lean_object* l_Lean_runEval___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Prim_iterate_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_withStderr___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__24;
 lean_object* l_IO_print___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_termPrintln_x21_______closed__4;
 lean_object* l_EIO_catchExceptions_match__1(lean_object*, lean_object*, lean_object*);
 uint8_t l_IO_AccessRight_execution___default;
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__10;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__2;
 lean_object* l_IO_Prim_fopenFlags___closed__2;
 lean_object* l_Lean_instEvalIO(lean_object*);
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097____boxed(lean_object*, lean_object*);
 lean_object* l_IO_withStdout___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_tryFinally___rarg___closed__1;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__15;
 lean_object* lean_uint32_to_nat(uint32_t);
 uint32_t l_IO_AccessRight_flags___closed__5;
 lean_object* l_IO_withStdout___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_prim_handle_mk(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_1198____closed__6;
 lean_object* l_IO_FS_Stream_ofBuffer___closed__1;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____boxed(lean_object*, lean_object*);
 lean_object* l_IO_FS_readBinFile___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_getStdout___at_IO_print___spec__1(lean_object*);
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__3;
 lean_object* l_IO_appDir___rarg(lean_object*, lean_object*);
 lean_object* l_IO_currentDir___rarg(lean_object*);
+lean_object* l_IO_FS_instReprDirEntry;
 lean_object* lean_task_get_own(lean_object*);
 uint32_t l_IO_AccessRight_flags___closed__7;
 uint32_t l_IO_FileRight_flags(lean_object*);
@@ -472,20 +596,23 @@ lean_object* l_IO_setStdin(lean_object*);
 lean_object* l_EIO_catchExceptions___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_Prim_setStdin___boxed(lean_object*, lean_object*);
 lean_object* l_instOrElseEIO___closed__1;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__14;
 lean_object* l_termPrintln_x21_______closed__1;
 lean_object* l_IO_Prim_Handle_read___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_ByteArray_findIdx_x3f_loop___at_IO_FS_Stream_ofBuffer___elambda__2___spec__1(lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags___closed__13;
+lean_object* l_IO_mapTasks_go_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint32_t l_IO_AccessRight_flags___closed__3;
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_IO_FS_withFile(lean_object*);
 lean_object* l_IO_Prim_getStdin___boxed(lean_object*);
 lean_object* l_IO_Prim_Handle_flush___boxed(lean_object*, lean_object*);
 lean_object* l_IO_Process_output(lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
 lean_object* l_IO_mkRef___at_IO_FS_withIsolatedStreams___spec__1(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 uint8_t l_IO_AccessRight_read___default;
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__18;
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__1;
+lean_object* l_Repr_addAppParen(lean_object*, lean_object*);
 lean_object* l_EIO_catchExceptions_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -1134,6 +1261,104 @@ x_7 = lean_io_bind_task(x_3, x_4, x_5, x_6);
 return x_7;
 }
 }
+lean_object* l_IO_mapTasks_go_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_3);
+x_5 = lean_apply_1(x_4, x_2);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_3(x_3, x_6, x_7, x_2);
+return x_8;
+}
+}
+}
+lean_object* l_IO_mapTasks_go_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_IO_mapTasks_go_match__1___rarg), 4, 0);
+return x_3;
+}
+}
+lean_object* l_IO_mapTasks_go___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; 
+x_7 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_7, 0, x_5);
+lean_ctor_set(x_7, 1, x_1);
+x_8 = l_IO_mapTasks_go___rarg(x_2, x_3, x_4, x_7, x_6);
+return x_8;
+}
+}
+lean_object* l_IO_mapTasks_go___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+if (lean_obj_tag(x_3) == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_6 = l_List_reverse___rarg(x_4);
+x_7 = lean_apply_1(x_1, x_6);
+x_8 = lean_io_as_task(x_7, x_2, x_5);
+return x_8;
+}
+else
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_9 = lean_ctor_get(x_3, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_3, 1);
+lean_inc(x_10);
+lean_dec(x_3);
+lean_inc(x_2);
+x_11 = lean_alloc_closure((void*)(l_IO_mapTasks_go___rarg___lambda__1), 6, 4);
+lean_closure_set(x_11, 0, x_4);
+lean_closure_set(x_11, 1, x_1);
+lean_closure_set(x_11, 2, x_2);
+lean_closure_set(x_11, 3, x_10);
+x_12 = lean_io_bind_task(x_9, x_11, x_2, x_5);
+return x_12;
+}
+}
+}
+lean_object* l_IO_mapTasks_go(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_IO_mapTasks_go___rarg), 5, 0);
+return x_3;
+}
+}
+lean_object* l_IO_mapTasks___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; 
+x_5 = lean_box(0);
+x_6 = l_IO_mapTasks_go___rarg(x_1, x_3, x_2, x_5, x_4);
+return x_6;
+}
+}
+lean_object* l_IO_mapTasks(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_IO_mapTasks___rarg), 4, 0);
+return x_3;
+}
+}
 lean_object* l_IO_checkCanceled___boxed(lean_object* x_1) {
 _start:
 {
@@ -1704,24 +1929,6 @@ x_3 = lean_io_realpath(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_IO_Prim_isDir___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_io_is_dir(x_1, x_2);
-lean_dec(x_1);
-return x_3;
-}
-}
-lean_object* l_IO_Prim_fileExists___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_io_file_exists(x_1, x_2);
-lean_dec(x_1);
-return x_3;
-}
-}
 lean_object* l_IO_Prim_removeFile___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -2424,6 +2631,1654 @@ x_2 = lean_alloc_closure((void*)(l_IO_FS_Stream_putStrLn___rarg), 3, 0);
 return x_2;
 }
 }
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("root");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__1;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__2;
+x_3 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__3;
+x_2 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__4;
+x_3 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__5() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("fileName");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__5;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641_(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 
+x_3 = lean_ctor_get(x_1, 0);
+x_4 = l_String_quote(x_3);
+x_5 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_5, 0, x_4);
+x_6 = l_System_instReprFilePath___closed__2;
+x_7 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_7, 0, x_6);
+lean_ctor_set(x_7, 1, x_5);
+x_8 = lean_unsigned_to_nat(0u);
+x_9 = l_Repr_addAppParen(x_7, x_8);
+x_10 = l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__4;
+x_11 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_11, 0, x_10);
+lean_ctor_set(x_11, 1, x_9);
+x_12 = l_instReprProd___rarg___closed__1;
+x_13 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_13, 0, x_11);
+lean_ctor_set(x_13, 1, x_12);
+x_14 = lean_box(1);
+x_15 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set(x_15, 1, x_14);
+x_16 = l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__6;
+x_17 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_17, 0, x_15);
+lean_ctor_set(x_17, 1, x_16);
+x_18 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__4;
+x_19 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_19, 0, x_17);
+lean_ctor_set(x_19, 1, x_18);
+x_20 = lean_ctor_get(x_1, 1);
+x_21 = l_String_quote(x_20);
+x_22 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_22, 0, x_21);
+x_23 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_23, 0, x_19);
+lean_ctor_set(x_23, 1, x_22);
+x_24 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__30;
+x_25 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_25, 0, x_24);
+lean_ctor_set(x_25, 1, x_23);
+x_26 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__31;
+x_27 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_27, 0, x_25);
+lean_ctor_set(x_27, 1, x_26);
+x_28 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__29;
+x_29 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_29, 0, x_28);
+lean_ctor_set(x_29, 1, x_27);
+x_30 = 0;
+x_31 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_31, 0, x_29);
+lean_ctor_set_uint8(x_31, sizeof(void*)*1, x_30);
+return x_31;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641_(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+static lean_object* _init_l_IO_FS_instReprDirEntry___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instReprDirEntry() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instReprDirEntry___closed__1;
+return x_1;
+}
+}
+lean_object* l_IO_FS_DirEntry_path(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = lean_ctor_get(x_1, 1);
+lean_inc(x_3);
+lean_dec(x_1);
+x_4 = l_System_FilePath_join(x_2, x_3);
+lean_dec(x_3);
+return x_4;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+switch (x_1) {
+case 0:
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+case 1:
+{
+lean_object* x_8; lean_object* x_9; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_8 = lean_box(0);
+x_9 = lean_apply_1(x_3, x_8);
+return x_9;
+}
+case 2:
+{
+lean_object* x_10; lean_object* x_11; 
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_10 = lean_box(0);
+x_11 = lean_apply_1(x_4, x_10);
+return x_11;
+}
+default: 
+{
+lean_object* x_12; lean_object* x_13; 
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_box(0);
+x_13 = lean_apply_1(x_5, x_12);
+return x_13;
+}
+}
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1___rarg___boxed), 5, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; lean_object* x_7; 
+x_6 = lean_unbox(x_1);
+lean_dec(x_1);
+x_7 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737__match__1___rarg(x_6, x_2, x_3, x_4, x_5);
+return x_7;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("IO.FS.FileType.dir");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__1;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Data_Repr_0__reprSourceInfo____x40_Init_Data_Repr___hyg_1438____closed__4;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__2;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__4() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__3;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__5() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Int_pow___closed__1;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__2;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__6() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__5;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__7() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("IO.FS.FileType.file");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__8() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__7;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__9() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Data_Repr_0__reprSourceInfo____x40_Init_Data_Repr___hyg_1438____closed__4;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__8;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__10() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__9;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__11() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Int_pow___closed__1;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__8;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__12() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__11;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__13() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("IO.FS.FileType.symlink");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__14() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__13;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__15() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Data_Repr_0__reprSourceInfo____x40_Init_Data_Repr___hyg_1438____closed__4;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__14;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__16() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__15;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__17() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Int_pow___closed__1;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__14;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__18() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__17;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__19() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("IO.FS.FileType.other");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__20() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__19;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__21() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Data_Repr_0__reprSourceInfo____x40_Init_Data_Repr___hyg_1438____closed__4;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__20;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__22() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__21;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__23() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Int_pow___closed__1;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__20;
+x_3 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__24() {
+_start:
+{
+lean_object* x_1; uint8_t x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__23;
+x_2 = 0;
+x_3 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737_(uint8_t x_1, lean_object* x_2) {
+_start:
+{
+switch (x_1) {
+case 0:
+{
+lean_object* x_3; uint8_t x_4; 
+x_3 = lean_unsigned_to_nat(1024u);
+x_4 = lean_nat_dec_le(x_3, x_2);
+if (x_4 == 0)
+{
+lean_object* x_5; lean_object* x_6; 
+x_5 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__4;
+x_6 = l_Repr_addAppParen(x_5, x_2);
+return x_6;
+}
+else
+{
+lean_object* x_7; lean_object* x_8; 
+x_7 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__6;
+x_8 = l_Repr_addAppParen(x_7, x_2);
+return x_8;
+}
+}
+case 1:
+{
+lean_object* x_9; uint8_t x_10; 
+x_9 = lean_unsigned_to_nat(1024u);
+x_10 = lean_nat_dec_le(x_9, x_2);
+if (x_10 == 0)
+{
+lean_object* x_11; lean_object* x_12; 
+x_11 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__10;
+x_12 = l_Repr_addAppParen(x_11, x_2);
+return x_12;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; 
+x_13 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__12;
+x_14 = l_Repr_addAppParen(x_13, x_2);
+return x_14;
+}
+}
+case 2:
+{
+lean_object* x_15; uint8_t x_16; 
+x_15 = lean_unsigned_to_nat(1024u);
+x_16 = lean_nat_dec_le(x_15, x_2);
+if (x_16 == 0)
+{
+lean_object* x_17; lean_object* x_18; 
+x_17 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__16;
+x_18 = l_Repr_addAppParen(x_17, x_2);
+return x_18;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; 
+x_19 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__18;
+x_20 = l_Repr_addAppParen(x_19, x_2);
+return x_20;
+}
+}
+default: 
+{
+lean_object* x_21; uint8_t x_22; 
+x_21 = lean_unsigned_to_nat(1024u);
+x_22 = lean_nat_dec_le(x_21, x_2);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; 
+x_23 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__22;
+x_24 = l_Repr_addAppParen(x_23, x_2);
+return x_24;
+}
+else
+{
+lean_object* x_25; lean_object* x_26; 
+x_25 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__24;
+x_26 = l_Repr_addAppParen(x_25, x_2);
+return x_26;
+}
+}
+}
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = lean_unbox(x_1);
+lean_dec(x_1);
+x_4 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737_(x_3, x_2);
+lean_dec(x_2);
+return x_4;
+}
+}
+static lean_object* _init_l_IO_FS_instReprFileType___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instReprFileType() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instReprFileType___closed__1;
+return x_1;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1___rarg(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+_start:
+{
+switch (x_1) {
+case 0:
+{
+lean_object* x_8; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_8 = lean_box(x_2);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_7);
+x_9 = lean_box(0);
+x_10 = lean_apply_1(x_3, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_8);
+lean_dec(x_3);
+x_11 = lean_box(x_1);
+x_12 = lean_box(x_2);
+x_13 = lean_apply_2(x_7, x_11, x_12);
+return x_13;
+}
+}
+case 1:
+{
+lean_object* x_14; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+x_14 = lean_box(x_2);
+if (lean_obj_tag(x_14) == 1)
+{
+lean_object* x_15; lean_object* x_16; 
+lean_dec(x_7);
+x_15 = lean_box(0);
+x_16 = lean_apply_1(x_4, x_15);
+return x_16;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_14);
+lean_dec(x_4);
+x_17 = lean_box(x_1);
+x_18 = lean_box(x_2);
+x_19 = lean_apply_2(x_7, x_17, x_18);
+return x_19;
+}
+}
+case 2:
+{
+lean_object* x_20; 
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+x_20 = lean_box(x_2);
+if (lean_obj_tag(x_20) == 2)
+{
+lean_object* x_21; lean_object* x_22; 
+lean_dec(x_7);
+x_21 = lean_box(0);
+x_22 = lean_apply_1(x_5, x_21);
+return x_22;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_20);
+lean_dec(x_5);
+x_23 = lean_box(x_1);
+x_24 = lean_box(x_2);
+x_25 = lean_apply_2(x_7, x_23, x_24);
+return x_25;
+}
+}
+default: 
+{
+lean_object* x_26; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_26 = lean_box(x_2);
+if (lean_obj_tag(x_26) == 3)
+{
+lean_object* x_27; lean_object* x_28; 
+lean_dec(x_7);
+x_27 = lean_box(0);
+x_28 = lean_apply_1(x_6, x_27);
+return x_28;
+}
+else
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_26);
+lean_dec(x_6);
+x_29 = lean_box(x_1);
+x_30 = lean_box(x_2);
+x_31 = lean_apply_2(x_7, x_29, x_30);
+return x_31;
+}
+}
+}
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1___rarg___boxed), 7, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+_start:
+{
+uint8_t x_8; uint8_t x_9; lean_object* x_10; 
+x_8 = lean_unbox(x_1);
+lean_dec(x_1);
+x_9 = lean_unbox(x_2);
+lean_dec(x_2);
+x_10 = l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855__match__1___rarg(x_8, x_9, x_3, x_4, x_5, x_6, x_7);
+return x_10;
+}
+}
+uint8_t l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855_(uint8_t x_1, uint8_t x_2) {
+_start:
+{
+switch (x_1) {
+case 0:
+{
+lean_object* x_3; 
+x_3 = lean_box(x_2);
+if (lean_obj_tag(x_3) == 0)
+{
+uint8_t x_4; 
+x_4 = 1;
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+lean_dec(x_3);
+x_5 = 0;
+return x_5;
+}
+}
+case 1:
+{
+lean_object* x_6; 
+x_6 = lean_box(x_2);
+if (lean_obj_tag(x_6) == 1)
+{
+uint8_t x_7; 
+x_7 = 1;
+return x_7;
+}
+else
+{
+uint8_t x_8; 
+lean_dec(x_6);
+x_8 = 0;
+return x_8;
+}
+}
+case 2:
+{
+lean_object* x_9; 
+x_9 = lean_box(x_2);
+if (lean_obj_tag(x_9) == 2)
+{
+uint8_t x_10; 
+x_10 = 1;
+return x_10;
+}
+else
+{
+uint8_t x_11; 
+lean_dec(x_9);
+x_11 = 0;
+return x_11;
+}
+}
+default: 
+{
+lean_object* x_12; 
+x_12 = lean_box(x_2);
+if (lean_obj_tag(x_12) == 3)
+{
+uint8_t x_13; 
+x_13 = 1;
+return x_13;
+}
+else
+{
+uint8_t x_14; 
+lean_dec(x_12);
+x_14 = 0;
+return x_14;
+}
+}
+}
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; uint8_t x_4; uint8_t x_5; lean_object* x_6; 
+x_3 = lean_unbox(x_1);
+lean_dec(x_1);
+x_4 = lean_unbox(x_2);
+lean_dec(x_2);
+x_5 = l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855_(x_3, x_4);
+x_6 = lean_box(x_5);
+return x_6;
+}
+}
+static lean_object* _init_l_IO_FS_instBEqFileType___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855____boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instBEqFileType() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instBEqFileType___closed__1;
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("sec");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__1;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__2;
+x_3 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__3;
+x_2 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__4;
+x_3 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__5() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("nsec");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__5;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952_(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint32_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; 
+x_3 = lean_ctor_get(x_1, 0);
+x_4 = l_Int_repr(x_3);
+x_5 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_5, 0, x_4);
+x_6 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__4;
+x_7 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_7, 0, x_6);
+lean_ctor_set(x_7, 1, x_5);
+x_8 = l_instReprProd___rarg___closed__1;
+x_9 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_9, 0, x_7);
+lean_ctor_set(x_9, 1, x_8);
+x_10 = lean_box(1);
+x_11 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_11, 0, x_9);
+lean_ctor_set(x_11, 1, x_10);
+x_12 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__6;
+x_13 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_13, 0, x_11);
+lean_ctor_set(x_13, 1, x_12);
+x_14 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__4;
+x_15 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set(x_15, 1, x_14);
+x_16 = lean_ctor_get_uint32(x_1, sizeof(void*)*1);
+x_17 = lean_uint32_to_nat(x_16);
+x_18 = l_Nat_repr(x_17);
+x_19 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_19, 0, x_18);
+x_20 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_20, 0, x_15);
+lean_ctor_set(x_20, 1, x_19);
+x_21 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__30;
+x_22 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_22, 0, x_21);
+lean_ctor_set(x_22, 1, x_20);
+x_23 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__31;
+x_24 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_24, 0, x_22);
+lean_ctor_set(x_24, 1, x_23);
+x_25 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__29;
+x_26 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_26, 0, x_25);
+lean_ctor_set(x_26, 1, x_24);
+x_27 = 0;
+x_28 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_28, 0, x_26);
+lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_27);
+return x_28;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952_(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+static lean_object* _init_l_IO_FS_instReprSystemTime___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instReprSystemTime() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instReprSystemTime___closed__1;
+return x_1;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; uint32_t x_6; lean_object* x_7; uint32_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get_uint32(x_1, sizeof(void*)*1);
+lean_dec(x_1);
+x_7 = lean_ctor_get(x_2, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get_uint32(x_2, sizeof(void*)*1);
+lean_dec(x_2);
+x_9 = lean_box_uint32(x_6);
+x_10 = lean_box_uint32(x_8);
+x_11 = lean_apply_4(x_3, x_5, x_9, x_7, x_10);
+return x_11;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016__match__1___rarg(x_1, x_2, x_3, x_4);
+lean_dec(x_4);
+return x_5;
+}
+}
+uint8_t l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016_(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; uint32_t x_4; lean_object* x_5; uint32_t x_6; uint8_t x_7; 
+x_3 = lean_ctor_get(x_1, 0);
+x_4 = lean_ctor_get_uint32(x_1, sizeof(void*)*1);
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_ctor_get_uint32(x_2, sizeof(void*)*1);
+x_7 = lean_int_dec_eq(x_3, x_5);
+if (x_7 == 0)
+{
+uint8_t x_8; 
+x_8 = 0;
+return x_8;
+}
+else
+{
+uint8_t x_9; 
+x_9 = x_4 == x_6;
+return x_9;
+}
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016_(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+static lean_object* _init_l_IO_FS_instBEqSystemTime___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_beqSystemTime____x40_Init_System_IO___hyg_2016____boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instBEqSystemTime() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instBEqSystemTime___closed__1;
+return x_1;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (x_1) {
+case 0:
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_7 = lean_box(0);
+x_8 = lean_apply_1(x_4, x_7);
+return x_8;
+}
+default: 
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_9 = lean_box(0);
+x_10 = lean_apply_1(x_3, x_9);
+return x_10;
+}
+}
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; lean_object* x_6; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__1___rarg(x_5, x_2, x_3, x_4);
+return x_6;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint32_t x_5; lean_object* x_6; uint32_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get_uint32(x_1, sizeof(void*)*1);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_2, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get_uint32(x_2, sizeof(void*)*1);
+lean_dec(x_2);
+x_8 = lean_box_uint32(x_5);
+x_9 = lean_box_uint32(x_7);
+x_10 = lean_apply_4(x_3, x_4, x_8, x_6, x_9);
+return x_10;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097__match__2___rarg), 3, 0);
+return x_2;
+}
+}
+uint8_t l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097_(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; uint32_t x_4; lean_object* x_5; uint32_t x_6; uint8_t x_7; 
+x_3 = lean_ctor_get(x_1, 0);
+x_4 = lean_ctor_get_uint32(x_1, sizeof(void*)*1);
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_ctor_get_uint32(x_2, sizeof(void*)*1);
+x_7 = lean_int_dec_lt(x_3, x_5);
+if (x_7 == 0)
+{
+uint8_t x_8; 
+x_8 = lean_int_dec_eq(x_3, x_5);
+if (x_8 == 0)
+{
+uint8_t x_9; 
+x_9 = 2;
+return x_9;
+}
+else
+{
+uint8_t x_10; 
+x_10 = x_4 < x_6;
+if (x_10 == 0)
+{
+uint8_t x_11; 
+x_11 = x_4 == x_6;
+if (x_11 == 0)
+{
+uint8_t x_12; 
+x_12 = 2;
+return x_12;
+}
+else
+{
+uint8_t x_13; 
+x_13 = 1;
+return x_13;
+}
+}
+else
+{
+uint8_t x_14; 
+x_14 = 0;
+return x_14;
+}
+}
+}
+else
+{
+uint8_t x_15; 
+x_15 = 0;
+return x_15;
+}
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097_(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+static lean_object* _init_l_IO_FS_instOrdSystemTime___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_ordSystemTime____x40_Init_System_IO___hyg_2097____boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instOrdSystemTime() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instOrdSystemTime___closed__1;
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instInhabitedSystemTime___closed__1() {
+_start:
+{
+lean_object* x_1; uint32_t x_2; lean_object* x_3; 
+x_1 = l_Int_instInhabitedInt___closed__1;
+x_2 = l_instInhabitedUInt32___closed__1;
+x_3 = lean_alloc_ctor(0, 1, 4);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set_uint32(x_3, sizeof(void*)*1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l_IO_FS_instInhabitedSystemTime() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instInhabitedSystemTime___closed__1;
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instLTSystemTime() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_box(0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instLESystemTime() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_box(0);
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("accessed");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__1;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__2;
+x_3 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__3;
+x_2 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__4;
+x_3 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__5() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("modified");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__5;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__7() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("byteSize");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__8() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__7;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("type");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__10() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280_(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint64_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; 
+x_3 = lean_ctor_get(x_1, 0);
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952_(x_3, x_4);
+x_6 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__4;
+x_7 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_7, 0, x_6);
+lean_ctor_set(x_7, 1, x_5);
+x_8 = l_instReprProd___rarg___closed__1;
+x_9 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_9, 0, x_7);
+lean_ctor_set(x_9, 1, x_8);
+x_10 = lean_box(1);
+x_11 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_11, 0, x_9);
+lean_ctor_set(x_11, 1, x_10);
+x_12 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__6;
+x_13 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_13, 0, x_11);
+lean_ctor_set(x_13, 1, x_12);
+x_14 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__4;
+x_15 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set(x_15, 1, x_14);
+x_16 = lean_ctor_get(x_1, 1);
+x_17 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952_(x_16, x_4);
+x_18 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_18, 0, x_15);
+lean_ctor_set(x_18, 1, x_17);
+x_19 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_19, 0, x_18);
+lean_ctor_set(x_19, 1, x_8);
+x_20 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_10);
+x_21 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__8;
+x_22 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_21);
+x_23 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_23, 0, x_22);
+lean_ctor_set(x_23, 1, x_14);
+x_24 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+x_25 = lean_uint64_to_nat(x_24);
+x_26 = l_Nat_repr(x_25);
+x_27 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_27, 0, x_26);
+x_28 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_28, 0, x_23);
+lean_ctor_set(x_28, 1, x_27);
+x_29 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_29, 0, x_28);
+lean_ctor_set(x_29, 1, x_8);
+x_30 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_10);
+x_31 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__10;
+x_32 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_32, 0, x_30);
+lean_ctor_set(x_32, 1, x_31);
+x_33 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_33, 0, x_32);
+lean_ctor_set(x_33, 1, x_14);
+x_34 = lean_ctor_get_uint8(x_1, sizeof(void*)*2 + 8);
+x_35 = l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737_(x_34, x_4);
+x_36 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_36, 0, x_33);
+lean_ctor_set(x_36, 1, x_35);
+x_37 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__30;
+x_38 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_38, 0, x_37);
+lean_ctor_set(x_38, 1, x_36);
+x_39 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__31;
+x_40 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_39);
+x_41 = l___private_Init_Meta_0__Lean_Meta_Simp_reprConfig____x40_Init_Meta___hyg_6907____closed__29;
+x_42 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_42, 0, x_41);
+lean_ctor_set(x_42, 1, x_40);
+x_43 = 0;
+x_44 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_44, 0, x_42);
+lean_ctor_set_uint8(x_44, sizeof(void*)*1, x_43);
+return x_44;
+}
+}
+lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280_(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+static lean_object* _init_l_IO_FS_instReprMetadata___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____boxed), 2, 0);
+return x_1;
+}
+}
+static lean_object* _init_l_IO_FS_instReprMetadata() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_IO_FS_instReprMetadata___closed__1;
+return x_1;
+}
+}
+lean_object* l_System_FilePath_readDir___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_io_read_dir(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_metadata___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_io_metadata(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_isDir(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_io_metadata(x_1, x_2);
+if (lean_obj_tag(x_3) == 0)
+{
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_3);
+if (x_4 == 0)
+{
+lean_object* x_5; uint8_t x_6; uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_5 = lean_ctor_get(x_3, 0);
+x_6 = lean_ctor_get_uint8(x_5, sizeof(void*)*2 + 8);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855_(x_6, x_7);
+x_9 = lean_box(x_8);
+lean_ctor_set(x_3, 0, x_9);
+return x_3;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; uint8_t x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; 
+x_10 = lean_ctor_get(x_3, 0);
+x_11 = lean_ctor_get(x_3, 1);
+lean_inc(x_11);
+lean_inc(x_10);
+lean_dec(x_3);
+x_12 = lean_ctor_get_uint8(x_10, sizeof(void*)*2 + 8);
+lean_dec(x_10);
+x_13 = 0;
+x_14 = l___private_Init_System_IO_0__IO_FS_beqFileType____x40_Init_System_IO___hyg_1855_(x_12, x_13);
+x_15 = lean_box(x_14);
+x_16 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_16, 0, x_15);
+lean_ctor_set(x_16, 1, x_11);
+return x_16;
+}
+}
+else
+{
+uint8_t x_17; 
+x_17 = !lean_is_exclusive(x_3);
+if (x_17 == 0)
+{
+lean_object* x_18; uint8_t x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_3, 0);
+lean_dec(x_18);
+x_19 = 0;
+x_20 = lean_box(x_19);
+lean_ctor_set_tag(x_3, 0);
+lean_ctor_set(x_3, 0, x_20);
+return x_3;
+}
+else
+{
+lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; 
+x_21 = lean_ctor_get(x_3, 1);
+lean_inc(x_21);
+lean_dec(x_3);
+x_22 = 0;
+x_23 = lean_box(x_22);
+x_24 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_24, 0, x_23);
+lean_ctor_set(x_24, 1, x_21);
+return x_24;
+}
+}
+}
+}
+lean_object* l_System_FilePath_isDir___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_isDir(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_System_FilePath_pathExists(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_io_metadata(x_1, x_2);
+if (lean_obj_tag(x_3) == 0)
+{
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_3);
+if (x_4 == 0)
+{
+lean_object* x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_3, 0);
+lean_dec(x_5);
+x_6 = 1;
+x_7 = lean_box(x_6);
+lean_ctor_set(x_3, 0, x_7);
+return x_3;
+}
+else
+{
+lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; 
+x_8 = lean_ctor_get(x_3, 1);
+lean_inc(x_8);
+lean_dec(x_3);
+x_9 = 1;
+x_10 = lean_box(x_9);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_10);
+lean_ctor_set(x_11, 1, x_8);
+return x_11;
+}
+}
+else
+{
+uint8_t x_12; 
+x_12 = !lean_is_exclusive(x_3);
+if (x_12 == 0)
+{
+lean_object* x_13; uint8_t x_14; lean_object* x_15; 
+x_13 = lean_ctor_get(x_3, 0);
+lean_dec(x_13);
+x_14 = 0;
+x_15 = lean_box(x_14);
+lean_ctor_set_tag(x_3, 0);
+lean_ctor_set(x_3, 0, x_15);
+return x_3;
+}
+else
+{
+lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; 
+x_16 = lean_ctor_get(x_3, 1);
+lean_inc(x_16);
+lean_dec(x_3);
+x_17 = 0;
+x_18 = lean_box(x_17);
+x_19 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_19, 0, x_18);
+lean_ctor_set(x_19, 1, x_16);
+return x_19;
+}
+}
+}
+}
+lean_object* l_System_FilePath_pathExists___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_System_FilePath_pathExists(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
 static lean_object* _init_l_IO_getStdin___rarg___closed__1() {
 _start:
 {
@@ -3010,42 +4865,6 @@ x_2 = lean_alloc_closure((void*)(l_IO_realPath___rarg), 2, 0);
 return x_2;
 }
 }
-lean_object* l_IO_isDir___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; 
-x_3 = lean_alloc_closure((void*)(l_IO_Prim_isDir___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = lean_apply_2(x_1, lean_box(0), x_3);
-return x_4;
-}
-}
-lean_object* l_IO_isDir(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_IO_isDir___rarg), 2, 0);
-return x_2;
-}
-}
-lean_object* l_IO_fileExists___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; 
-x_3 = lean_alloc_closure((void*)(l_IO_Prim_fileExists___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = lean_apply_2(x_1, lean_box(0), x_3);
-return x_4;
-}
-}
-lean_object* l_IO_fileExists(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_IO_fileExists___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* l_IO_removeFile___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -3165,7 +4984,6 @@ lean_dec(x_1);
 x_6 = lean_ctor_get(x_5, 1);
 lean_inc(x_6);
 lean_dec(x_5);
-lean_inc(x_4);
 x_7 = l_System_FilePath_parent(x_4);
 x_8 = lean_apply_2(x_6, lean_box(0), x_7);
 x_9 = lean_alloc_closure((void*)(l_IO_appDir___rarg___lambda__1___boxed), 3, 2);
@@ -3235,6 +5053,225 @@ x_2 = lean_alloc_closure((void*)(l_IO_currentDir___rarg), 1, 0);
 return x_2;
 }
 }
+lean_object* l_IO_createDir___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_io_create_dir(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_IO_createDirAll___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_io_create_dir(x_1, x_3);
+if (lean_obj_tag(x_4) == 0)
+{
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_4, 1);
+lean_inc(x_6);
+lean_dec(x_4);
+x_7 = l_System_FilePath_isDir(x_1, x_6);
+x_8 = lean_ctor_get(x_7, 0);
+lean_inc(x_8);
+x_9 = lean_unbox(x_8);
+lean_dec(x_8);
+if (x_9 == 0)
+{
+uint8_t x_10; 
+x_10 = !lean_is_exclusive(x_7);
+if (x_10 == 0)
+{
+lean_object* x_11; 
+x_11 = lean_ctor_get(x_7, 0);
+lean_dec(x_11);
+lean_ctor_set_tag(x_7, 1);
+lean_ctor_set(x_7, 0, x_5);
+return x_7;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; 
+x_12 = lean_ctor_get(x_7, 1);
+lean_inc(x_12);
+lean_dec(x_7);
+x_13 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_13, 0, x_5);
+lean_ctor_set(x_13, 1, x_12);
+return x_13;
+}
+}
+else
+{
+uint8_t x_14; 
+lean_dec(x_5);
+x_14 = !lean_is_exclusive(x_7);
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; 
+x_15 = lean_ctor_get(x_7, 0);
+lean_dec(x_15);
+x_16 = lean_box(0);
+lean_ctor_set(x_7, 0, x_16);
+return x_7;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_17 = lean_ctor_get(x_7, 1);
+lean_inc(x_17);
+lean_dec(x_7);
+x_18 = lean_box(0);
+x_19 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_19, 0, x_18);
+lean_ctor_set(x_19, 1, x_17);
+return x_19;
+}
+}
+}
+}
+}
+lean_object* l_IO_createDirAll___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_System_FilePath_parent(x_1);
+if (lean_obj_tag(x_4) == 0)
+{
+lean_object* x_5; lean_object* x_6; 
+x_5 = lean_box(0);
+x_6 = l_IO_createDirAll___lambda__1(x_1, x_5, x_3);
+return x_6;
+}
+else
+{
+lean_object* x_7; lean_object* x_8; 
+x_7 = lean_ctor_get(x_4, 0);
+lean_inc(x_7);
+lean_dec(x_4);
+x_8 = l_IO_createDirAll(x_7, x_3);
+lean_dec(x_7);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_9 = lean_ctor_get(x_8, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+lean_dec(x_8);
+x_11 = l_IO_createDirAll___lambda__1(x_1, x_9, x_10);
+lean_dec(x_9);
+return x_11;
+}
+else
+{
+uint8_t x_12; 
+x_12 = !lean_is_exclusive(x_8);
+if (x_12 == 0)
+{
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_13 = lean_ctor_get(x_8, 0);
+x_14 = lean_ctor_get(x_8, 1);
+lean_inc(x_14);
+lean_inc(x_13);
+lean_dec(x_8);
+x_15 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set(x_15, 1, x_14);
+return x_15;
+}
+}
+}
+}
+}
+lean_object* l_IO_createDirAll(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; uint8_t x_5; 
+x_3 = l_System_FilePath_isDir(x_1, x_2);
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_unbox(x_4);
+lean_dec(x_4);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_6 = lean_ctor_get(x_3, 1);
+lean_inc(x_6);
+lean_dec(x_3);
+x_7 = lean_box(0);
+x_8 = l_IO_createDirAll___lambda__2(x_1, x_7, x_6);
+return x_8;
+}
+else
+{
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_3);
+if (x_9 == 0)
+{
+lean_object* x_10; lean_object* x_11; 
+x_10 = lean_ctor_get(x_3, 0);
+lean_dec(x_10);
+x_11 = lean_box(0);
+lean_ctor_set(x_3, 0, x_11);
+return x_3;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_12 = lean_ctor_get(x_3, 1);
+lean_inc(x_12);
+lean_dec(x_3);
+x_13 = lean_box(0);
+x_14 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_14, 0, x_13);
+lean_ctor_set(x_14, 1, x_12);
+return x_14;
+}
+}
+}
+}
+lean_object* l_IO_createDirAll___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_IO_createDirAll___lambda__1(x_1, x_2, x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_IO_createDirAll___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_IO_createDirAll___lambda__2(x_1, x_2, x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_IO_createDirAll___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_IO_createDirAll(x_1, x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
 lean_object* l_IO_Process_Stdio_toHandleType_match__1___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -6734,7 +8771,7 @@ x_1 = l_termPrintln_x21_______closed__7;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -6742,22 +8779,22 @@ x_1 = lean_mk_string("IO.println");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__1;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__1;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__1;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__1;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__2;
+x_3 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__2;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -6765,7 +8802,7 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -6773,17 +8810,17 @@ x_1 = lean_mk_string("IO");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__4;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__4;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__6() {
 _start:
 {
 lean_object* x_1; 
@@ -6791,56 +8828,56 @@ x_1 = lean_mk_string("println");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__7() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__6;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__6;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__8() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__7;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__7;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__9() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__8;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__8;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__10() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__4;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__4;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__11() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__11() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__4;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__4;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__10;
+x_3 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__10;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -6848,31 +8885,31 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__12() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__13() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__12;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__12;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__14() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__14() {
 _start:
 {
 lean_object* x_1; 
@@ -6880,22 +8917,22 @@ x_1 = lean_mk_string("Unit");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__15() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__15() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__14;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__14;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__16() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__16() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__14;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__14;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__15;
+x_3 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__15;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -6903,41 +8940,41 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__17() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__17() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__14;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__14;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__18() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__18() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__19() {
+static lean_object* _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__19() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__18;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__18;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_myMacro____x40_Init_System_IO___hyg_3180_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_System_IO___hyg_4276_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -6985,12 +9022,12 @@ lean_inc(x_15);
 x_19 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_19, 0, x_15);
 lean_ctor_set(x_19, 1, x_18);
-x_20 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__7;
+x_20 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__7;
 lean_inc(x_16);
 lean_inc(x_17);
 x_21 = l_Lean_addMacroScope(x_17, x_20, x_16);
-x_22 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__3;
-x_23 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__9;
+x_22 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__3;
+x_23 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__9;
 lean_inc(x_15);
 x_24 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_24, 0, x_15);
@@ -7015,22 +9052,22 @@ lean_inc(x_15);
 x_35 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_35, 0, x_15);
 lean_ctor_set(x_35, 1, x_34);
-x_36 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_36 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_inc(x_16);
 lean_inc(x_17);
 x_37 = l_Lean_addMacroScope(x_17, x_36, x_16);
-x_38 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
-x_39 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__13;
+x_38 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
+x_39 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__13;
 lean_inc(x_15);
 x_40 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_40, 0, x_15);
 lean_ctor_set(x_40, 1, x_38);
 lean_ctor_set(x_40, 2, x_37);
 lean_ctor_set(x_40, 3, x_39);
-x_41 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_41 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_42 = l_Lean_addMacroScope(x_17, x_41, x_16);
-x_43 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
-x_44 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
+x_43 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
+x_44 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 lean_inc(x_15);
 x_45 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_45, 0, x_15);
@@ -7094,12 +9131,12 @@ lean_inc(x_68);
 x_73 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_73, 0, x_68);
 lean_ctor_set(x_73, 1, x_72);
-x_74 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__7;
+x_74 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__7;
 lean_inc(x_70);
 lean_inc(x_71);
 x_75 = l_Lean_addMacroScope(x_71, x_74, x_70);
-x_76 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__3;
-x_77 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__9;
+x_76 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__3;
+x_77 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__9;
 lean_inc(x_68);
 x_78 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_78, 0, x_68);
@@ -7124,22 +9161,22 @@ lean_inc(x_68);
 x_89 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_89, 0, x_68);
 lean_ctor_set(x_89, 1, x_88);
-x_90 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_90 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_inc(x_70);
 lean_inc(x_71);
 x_91 = l_Lean_addMacroScope(x_71, x_90, x_70);
-x_92 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
-x_93 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__13;
+x_92 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
+x_93 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__13;
 lean_inc(x_68);
 x_94 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_94, 0, x_68);
 lean_ctor_set(x_94, 1, x_92);
 lean_ctor_set(x_94, 2, x_91);
 lean_ctor_set(x_94, 3, x_93);
-x_95 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_95 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_96 = l_Lean_addMacroScope(x_71, x_95, x_70);
-x_97 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
-x_98 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
+x_97 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
+x_98 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 lean_inc(x_68);
 x_99 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_99, 0, x_68);
@@ -7207,12 +9244,12 @@ lean_inc(x_125);
 x_129 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_129, 0, x_125);
 lean_ctor_set(x_129, 1, x_128);
-x_130 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__7;
+x_130 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__7;
 lean_inc(x_126);
 lean_inc(x_127);
 x_131 = l_Lean_addMacroScope(x_127, x_130, x_126);
-x_132 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__3;
-x_133 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__9;
+x_132 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__3;
+x_133 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__9;
 lean_inc(x_125);
 x_134 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_134, 0, x_125);
@@ -7269,22 +9306,22 @@ lean_inc(x_125);
 x_163 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_163, 0, x_125);
 lean_ctor_set(x_163, 1, x_162);
-x_164 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_164 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_inc(x_126);
 lean_inc(x_127);
 x_165 = l_Lean_addMacroScope(x_127, x_164, x_126);
-x_166 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
-x_167 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__13;
+x_166 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
+x_167 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__13;
 lean_inc(x_125);
 x_168 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_168, 0, x_125);
 lean_ctor_set(x_168, 1, x_166);
 lean_ctor_set(x_168, 2, x_165);
 lean_ctor_set(x_168, 3, x_167);
-x_169 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_169 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_170 = l_Lean_addMacroScope(x_127, x_169, x_126);
-x_171 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
-x_172 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
+x_171 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
+x_172 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 x_173 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_173, 0, x_125);
 lean_ctor_set(x_173, 1, x_171);
@@ -7340,12 +9377,12 @@ lean_inc(x_191);
 x_196 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_196, 0, x_191);
 lean_ctor_set(x_196, 1, x_195);
-x_197 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__7;
+x_197 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__7;
 lean_inc(x_193);
 lean_inc(x_194);
 x_198 = l_Lean_addMacroScope(x_194, x_197, x_193);
-x_199 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__3;
-x_200 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__9;
+x_199 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__3;
+x_200 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__9;
 lean_inc(x_191);
 x_201 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_201, 0, x_191);
@@ -7402,22 +9439,22 @@ lean_inc(x_191);
 x_230 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_230, 0, x_191);
 lean_ctor_set(x_230, 1, x_229);
-x_231 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_231 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_inc(x_193);
 lean_inc(x_194);
 x_232 = l_Lean_addMacroScope(x_194, x_231, x_193);
-x_233 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
-x_234 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__13;
+x_233 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
+x_234 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__13;
 lean_inc(x_191);
 x_235 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_235, 0, x_191);
 lean_ctor_set(x_235, 1, x_233);
 lean_ctor_set(x_235, 2, x_232);
 lean_ctor_set(x_235, 3, x_234);
-x_236 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_236 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_237 = l_Lean_addMacroScope(x_194, x_236, x_193);
-x_238 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
-x_239 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
+x_238 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
+x_239 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 x_240 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_240, 0, x_191);
 lean_ctor_set(x_240, 1, x_238);
@@ -7469,6 +9506,7 @@ lean_object* initialize_Init_System_IOError(lean_object*);
 lean_object* initialize_Init_System_FilePath(lean_object*);
 lean_object* initialize_Init_System_ST(lean_object*);
 lean_object* initialize_Init_Data_ToString_Macro(lean_object*);
+lean_object* initialize_Init_Data_Ord(lean_object*);
 static bool _G_initialized = false;
 lean_object* initialize_Init_System_IO(lean_object* w) {
 lean_object * res;
@@ -7498,6 +9536,9 @@ lean_dec_ref(res);
 res = initialize_Init_Data_ToString_Macro(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Init_Data_Ord(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
 l_instMonadFinallyEIO___closed__1 = _init_l_instMonadFinallyEIO___closed__1();
 lean_mark_persistent(l_instMonadFinallyEIO___closed__1);
 l_instOrElseEIO___closed__1 = _init_l_instOrElseEIO___closed__1();
@@ -7528,6 +9569,134 @@ l_IO_Prim_fopenFlags___closed__12 = _init_l_IO_Prim_fopenFlags___closed__12();
 lean_mark_persistent(l_IO_Prim_fopenFlags___closed__12);
 l_IO_Prim_fopenFlags___closed__13 = _init_l_IO_Prim_fopenFlags___closed__13();
 lean_mark_persistent(l_IO_Prim_fopenFlags___closed__13);
+l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__1 = _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__1();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__1);
+l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__2 = _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__2();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__2);
+l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__3 = _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__3();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__3);
+l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__4 = _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__4();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__4);
+l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__5 = _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__5();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__5);
+l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__6 = _init_l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__6();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprDirEntry____x40_Init_System_IO___hyg_1641____closed__6);
+l_IO_FS_instReprDirEntry___closed__1 = _init_l_IO_FS_instReprDirEntry___closed__1();
+lean_mark_persistent(l_IO_FS_instReprDirEntry___closed__1);
+l_IO_FS_instReprDirEntry = _init_l_IO_FS_instReprDirEntry();
+lean_mark_persistent(l_IO_FS_instReprDirEntry);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__1 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__1();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__1);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__2 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__2();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__2);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__3 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__3();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__3);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__4 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__4();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__4);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__5 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__5();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__5);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__6 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__6();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__6);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__7 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__7();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__7);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__8 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__8();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__8);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__9 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__9();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__9);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__10 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__10();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__10);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__11 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__11();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__11);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__12 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__12();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__12);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__13 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__13();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__13);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__14 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__14();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__14);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__15 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__15();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__15);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__16 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__16();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__16);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__17 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__17();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__17);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__18 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__18();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__18);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__19 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__19();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__19);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__20 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__20();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__20);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__21 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__21();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__21);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__22 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__22();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__22);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__23 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__23();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__23);
+l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__24 = _init_l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__24();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprFileType____x40_Init_System_IO___hyg_1737____closed__24);
+l_IO_FS_instReprFileType___closed__1 = _init_l_IO_FS_instReprFileType___closed__1();
+lean_mark_persistent(l_IO_FS_instReprFileType___closed__1);
+l_IO_FS_instReprFileType = _init_l_IO_FS_instReprFileType();
+lean_mark_persistent(l_IO_FS_instReprFileType);
+l_IO_FS_instBEqFileType___closed__1 = _init_l_IO_FS_instBEqFileType___closed__1();
+lean_mark_persistent(l_IO_FS_instBEqFileType___closed__1);
+l_IO_FS_instBEqFileType = _init_l_IO_FS_instBEqFileType();
+lean_mark_persistent(l_IO_FS_instBEqFileType);
+l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__1 = _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__1();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__1);
+l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__2 = _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__2();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__2);
+l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__3 = _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__3();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__3);
+l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__4 = _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__4();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__4);
+l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__5 = _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__5();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__5);
+l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__6 = _init_l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__6();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_1952____closed__6);
+l_IO_FS_instReprSystemTime___closed__1 = _init_l_IO_FS_instReprSystemTime___closed__1();
+lean_mark_persistent(l_IO_FS_instReprSystemTime___closed__1);
+l_IO_FS_instReprSystemTime = _init_l_IO_FS_instReprSystemTime();
+lean_mark_persistent(l_IO_FS_instReprSystemTime);
+l_IO_FS_instBEqSystemTime___closed__1 = _init_l_IO_FS_instBEqSystemTime___closed__1();
+lean_mark_persistent(l_IO_FS_instBEqSystemTime___closed__1);
+l_IO_FS_instBEqSystemTime = _init_l_IO_FS_instBEqSystemTime();
+lean_mark_persistent(l_IO_FS_instBEqSystemTime);
+l_IO_FS_instOrdSystemTime___closed__1 = _init_l_IO_FS_instOrdSystemTime___closed__1();
+lean_mark_persistent(l_IO_FS_instOrdSystemTime___closed__1);
+l_IO_FS_instOrdSystemTime = _init_l_IO_FS_instOrdSystemTime();
+lean_mark_persistent(l_IO_FS_instOrdSystemTime);
+l_IO_FS_instInhabitedSystemTime___closed__1 = _init_l_IO_FS_instInhabitedSystemTime___closed__1();
+lean_mark_persistent(l_IO_FS_instInhabitedSystemTime___closed__1);
+l_IO_FS_instInhabitedSystemTime = _init_l_IO_FS_instInhabitedSystemTime();
+lean_mark_persistent(l_IO_FS_instInhabitedSystemTime);
+l_IO_FS_instLTSystemTime = _init_l_IO_FS_instLTSystemTime();
+lean_mark_persistent(l_IO_FS_instLTSystemTime);
+l_IO_FS_instLESystemTime = _init_l_IO_FS_instLESystemTime();
+lean_mark_persistent(l_IO_FS_instLESystemTime);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__1 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__1();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__1);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__2 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__2();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__2);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__3 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__3();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__3);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__4 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__4();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__4);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__5 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__5();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__5);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__6 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__6();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__6);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__7 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__7();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__7);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__8 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__8();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__8);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9);
+l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__10 = _init_l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__10();
+lean_mark_persistent(l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__10);
+l_IO_FS_instReprMetadata___closed__1 = _init_l_IO_FS_instReprMetadata___closed__1();
+lean_mark_persistent(l_IO_FS_instReprMetadata___closed__1);
+l_IO_FS_instReprMetadata = _init_l_IO_FS_instReprMetadata();
+lean_mark_persistent(l_IO_FS_instReprMetadata);
 l_IO_getStdin___rarg___closed__1 = _init_l_IO_getStdin___rarg___closed__1();
 lean_mark_persistent(l_IO_getStdin___rarg___closed__1);
 l_IO_getStdout___rarg___closed__1 = _init_l_IO_getStdout___rarg___closed__1();
@@ -7605,44 +9774,44 @@ l_termPrintln_x21_______closed__7 = _init_l_termPrintln_x21_______closed__7();
 lean_mark_persistent(l_termPrintln_x21_______closed__7);
 l_termPrintln_x21____ = _init_l_termPrintln_x21____();
 lean_mark_persistent(l_termPrintln_x21____);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__1 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__1);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__2 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__2);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__3 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__3);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__4 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__4);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__5 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__5);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__6 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__6);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__7 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__7();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__7);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__8 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__8();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__8);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__9 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__9();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__9);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__10 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__10();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__10);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__11 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__11();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__11);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__12 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__12();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__12);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__13 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__13();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__13);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__14 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__14();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__14);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__15 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__15();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__15);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__16 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__16();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__16);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__17 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__17();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__17);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__18 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__18();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__18);
-l_myMacro____x40_Init_System_IO___hyg_3180____closed__19 = _init_l_myMacro____x40_Init_System_IO___hyg_3180____closed__19();
-lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_3180____closed__19);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__1 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__1);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__2 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__2);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__3 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__3);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__4 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__4);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__5 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__5);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__6 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__6);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__7 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__7();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__7);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__8 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__8();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__8);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__9 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__9();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__9);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__10 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__10();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__10);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__11 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__11();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__11);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__12 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__12();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__12);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__13 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__13();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__13);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__14 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__14();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__14);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__15 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__15();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__15);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__16 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__16();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__16);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__17 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__17();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__17);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__18 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__18();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__18);
+l_myMacro____x40_Init_System_IO___hyg_4276____closed__19 = _init_l_myMacro____x40_Init_System_IO___hyg_4276____closed__19();
+lean_mark_persistent(l_myMacro____x40_Init_System_IO___hyg_4276____closed__19);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Class.c b/stage0/stdlib/Lean/Class.c
index 948202dfbe..e22c87cff9 100644
--- a/stage0/stdlib/Lean/Class.c
+++ b/stage0/stdlib/Lean/Class.c
@@ -136,7 +136,7 @@ lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkEmptyEnvironment___lambda__1___closed__1;
 size_t l_USize_mul(size_t, size_t);
 lean_object* l_Lean_initFn____x40_Lean_Class___hyg_692____closed__5;
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_object* l___private_Lean_Class_0__Lean_checkOutParam_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkFVar(lean_object*);
 size_t lean_usize_of_nat(lean_object*);
@@ -1760,7 +1760,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_initFn____x40_Lean_Class___hyg_70____closed__2;
 x_2 = l_Lean_initFn____x40_Lean_Class___hyg_70____closed__3;
 x_3 = l_Lean_initFn____x40_Lean_Class___hyg_70____closed__4;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
diff --git a/stage0/stdlib/Lean/Compiler/ClosedTermCache.c b/stage0/stdlib/Lean/Compiler/ClosedTermCache.c
index b490e4e666..8c56ebdaf3 100644
--- a/stage0/stdlib/Lean/Compiler/ClosedTermCache.c
+++ b/stage0/stdlib/Lean/Compiler/ClosedTermCache.c
@@ -83,7 +83,7 @@ extern lean_object* l_Lean_persistentEnvExtensionsRef;
 size_t lean_usize_modn(size_t, lean_object*);
 lean_object* l_Lean_closedTermCacheExt;
 size_t l_USize_mul(size_t, size_t);
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_object* l_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____lambda__2(lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
@@ -1547,7 +1547,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____closed__2;
 x_2 = l_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____closed__3;
 x_3 = l_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____closed__4;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
diff --git a/stage0/stdlib/Lean/Compiler/ExternAttr.c b/stage0/stdlib/Lean/Compiler/ExternAttr.c
index 90ee8b7748..41fe032dc8 100644
--- a/stage0/stdlib/Lean/Compiler/ExternAttr.c
+++ b/stage0/stdlib/Lean/Compiler/ExternAttr.c
@@ -68,7 +68,6 @@ lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData
 lean_object* l_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_342____closed__1;
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_parseOptNum_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
-uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_getExternNameFor_match__1(lean_object*);
 uint8_t l_Lean_expandExternPatternAux___closed__1;
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -214,6 +213,7 @@ lean_object* l_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_342____closed__
 lean_object* lean_uint32_to_nat(uint32_t);
 lean_object* l_Array_anyMUnsafe_any___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_342____spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getExternEntryForAux_match__1(lean_object*);
+uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData___spec__3___closed__2;
 lean_object* l_Lean_ParametricAttribute_getParam___at_Lean_getExternAttrData___spec__1(lean_object*, lean_object*, lean_object*);
@@ -719,7 +719,7 @@ else
 {
 lean_object* x_17; uint8_t x_18; 
 x_17 = lean_box(0);
-x_18 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(x_14, x_17);
+x_18 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(x_14, x_17);
 if (x_18 == 0)
 {
 lean_object* x_19; lean_object* x_20; 
diff --git a/stage0/stdlib/Lean/Compiler/IR/Borrow.c b/stage0/stdlib/Lean/Compiler/IR/Borrow.c
index 6288e61f44..308ed81b0c 100644
--- a/stage0/stdlib/Lean/Compiler/IR/Borrow.c
+++ b/stage0/stdlib/Lean/Compiler/IR/Borrow.c
@@ -77,7 +77,6 @@ lean_object* l_Lean_IR_Borrow_ApplyParamMap_visitFnBody___closed__3;
 lean_object* l_Lean_IR_Borrow_InitParamMap_visitFnBody_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_IR_Borrow_InitParamMap_visitDecls___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_IR_Borrow_updateParamMap___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_IR_Borrow_BorrowInfState_owned___default;
 lean_object* l_Lean_IR_Borrow_OwnedSet_beq_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_instToFormatParamMap___closed__1;
@@ -248,6 +247,7 @@ lean_object* l_Lean_IR_Borrow_ownVar(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_getParamInfo___closed__5;
 lean_object* l_Lean_IR_Borrow_ParamMap_fmt___boxed(lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_IR_mkIndexSet___spec__1(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_IR_Borrow_InitParamMap_initBorrow___spec__1(size_t, size_t, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_ParamMap_instBEqKey___closed__1;
@@ -1133,7 +1133,7 @@ static lean_object* _init_l_Lean_IR_Borrow_ParamMap_fmt___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = lean_box(0);
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -1199,7 +1199,7 @@ x_10 = lean_usize_of_nat(x_3);
 lean_dec(x_3);
 x_11 = lean_box(0);
 x_12 = l_Array_foldlMUnsafe_fold___at_Lean_IR_Borrow_ParamMap_fmt___spec__2(x_2, x_9, x_10, x_11);
-x_13 = l_Int_Int_pow___closed__1;
+x_13 = l_Int_pow___closed__1;
 x_14 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_14, 0, x_13);
 lean_ctor_set(x_14, 1, x_12);
diff --git a/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c b/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c
index 272101e292..18bfa72e7a 100644
--- a/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c
+++ b/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c
@@ -203,8 +203,8 @@ extern lean_object* l_Lean_IR_instInhabitedParam;
 lean_object* l_Lean_IR_UnreachableBranches_Value_format___closed__5;
 lean_object* l_Lean_IR_UnreachableBranches_functionSummariesExt___elambda__2(lean_object*);
 size_t l_USize_mul(size_t, size_t);
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_object* l_List_format___at_Lean_IR_UnreachableBranches_Value_format___spec__3(lean_object*);
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
 lean_object* l_Lean_IR_UnreachableBranches_initFn____x40_Lean_Compiler_IR_ElimDeadBranches___hyg_609____closed__1;
 extern lean_object* l_instReprList___rarg___closed__2;
 lean_object* l_Lean_IR_UnreachableBranches_projValue___boxed(lean_object*, lean_object*);
@@ -4428,7 +4428,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_IR_UnreachableBranches_initFn____x40_Lean_Compiler_IR_ElimDeadBranches___hyg_609____closed__2;
 x_2 = l_Lean_IR_UnreachableBranches_initFn____x40_Lean_Compiler_IR_ElimDeadBranches___hyg_609____closed__3;
 x_3 = l_Lean_IR_UnreachableBranches_initFn____x40_Lean_Compiler_IR_ElimDeadBranches___hyg_609____closed__4;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
diff --git a/stage0/stdlib/Lean/Compiler/InitAttr.c b/stage0/stdlib/Lean/Compiler/InitAttr.c
index c7dac6df03..14b7695172 100644
--- a/stage0/stdlib/Lean/Compiler/InitAttr.c
+++ b/stage0/stdlib/Lean/Compiler/InitAttr.c
@@ -43,6 +43,7 @@ extern lean_object* l_Lean_registerInternalExceptionId___closed__2;
 lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttrUnsafe___spec__10___lambda__1___boxed(lean_object*);
 uint8_t lean_is_io_unit_regular_init_fn(lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__4;
 lean_object* lean_environment_find(lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttrUnsafe___closed__3;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
@@ -138,7 +139,6 @@ extern lean_object* l_Lean_KernelException_toMessageData___closed__3;
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 lean_object* l_Lean_registerInitAttrUnsafe_match__2(lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__4;
 uint8_t l_Lean_hasInitAttr(lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_setParam___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_InitAttr_0__Lean_isUnitType_match__1(lean_object*);
@@ -162,6 +162,7 @@ lean_object* l_Lean_regularInitAttr;
 uint8_t l_Lean_isIOUnitInitFn(lean_object*, lean_object*);
 lean_object* l_Lean_resolveGlobalConst___at_Lean_registerInitAttrUnsafe___spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_qpartition_loop___at_Lean_registerInitAttrUnsafe___spec__13(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__14;
 extern lean_object* l_Lean_instInhabitedName;
 lean_object* l_Lean_Environment_getModuleIdxFor_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttrUnsafe___spec__10___lambda__1(lean_object*);
@@ -184,7 +185,6 @@ lean_object* l_Lean_getInitFnNameForCore_x3f(lean_object*, lean_object*, lean_ob
 lean_object* l_Lean_registerParametricAttribute___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttrUnsafe___lambda__1___closed__8;
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__14;
 lean_object* l_Lean_Attribute_Builtin_getId_x3f(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttrUnsafe___lambda__1___closed__4;
 lean_object* l_Lean_registerInitAttrUnsafe___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -223,7 +223,7 @@ x_11 = lean_ctor_get(x_5, 1);
 lean_inc(x_11);
 x_12 = lean_ctor_get_usize(x_5, 2);
 lean_dec(x_5);
-x_13 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__4;
+x_13 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__4;
 x_14 = lean_string_dec_eq(x_11, x_13);
 lean_dec(x_11);
 if (x_14 == 0)
@@ -314,7 +314,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = lean_ctor_get(x_3, 1);
-x_7 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__4;
+x_7 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__4;
 x_8 = lean_string_dec_eq(x_6, x_7);
 if (x_8 == 0)
 {
@@ -392,7 +392,7 @@ x_8 = lean_ctor_get(x_4, 1);
 lean_inc(x_8);
 x_9 = lean_ctor_get_usize(x_4, 2);
 lean_dec(x_4);
-x_10 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__14;
+x_10 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__14;
 x_11 = lean_string_dec_eq(x_8, x_10);
 lean_dec(x_8);
 if (x_11 == 0)
@@ -465,7 +465,7 @@ if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; lean_object* x_5; uint8_t x_6; 
 x_4 = lean_ctor_get(x_2, 1);
-x_5 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__14;
+x_5 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__14;
 x_6 = lean_string_dec_eq(x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Compiler/Specialize.c b/stage0/stdlib/Lean/Compiler/Specialize.c
index 2e9a877ed0..f7df092fba 100644
--- a/stage0/stdlib/Lean/Compiler/Specialize.c
+++ b/stage0/stdlib/Lean/Compiler/Specialize.c
@@ -148,7 +148,7 @@ extern lean_object* l_Lean_mkEmptyEnvironment___lambda__1___closed__1;
 lean_object* l_Lean_Compiler_SpecState_cache___default___closed__1;
 lean_object* lean_add_specialization_info(lean_object*, lean_object*, lean_object*);
 size_t l_USize_mul(size_t, size_t);
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_object* l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_qpartition_loop___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_SpecState_cache___default___closed__2;
@@ -4631,7 +4631,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__4;
 x_2 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__1;
 x_3 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__2;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
diff --git a/stage0/stdlib/Lean/Data/Json/Basic.c b/stage0/stdlib/Lean/Data/Json/Basic.c
index b9e437abc7..068f2a870a 100644
--- a/stage0/stdlib/Lean/Data/Json/Basic.c
+++ b/stage0/stdlib/Lean/Data/Json/Basic.c
@@ -53,7 +53,6 @@ extern lean_object* l_instReprProd___rarg___closed__1;
 lean_object* l___private_Init_Data_String_Basic_0__Substring_nextn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_JsonNumber_lt_match__2___rarg(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Json_getObj_x3f_match__1(lean_object*);
 lean_object* l_Int_repr(lean_object*);
 lean_object* l_Lean_JsonNumber_shiftl_match__1(lean_object*);
@@ -94,6 +93,7 @@ lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_
 lean_object* l_Lean_Json_getNat_x3f___boxed(lean_object*);
 lean_object* l___private_Init_Data_String_Basic_0__Substring_takeRightWhileAux___at_Lean_JsonNumber_toString___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_JsonNumber_normalize(lean_object*);
+lean_object* l_Int_pow(lean_object*, lean_object*);
 lean_object* l_Lean_Json_instCoeIntJson(lean_object*);
 uint8_t l_Lean_JsonNumber_instOrdJsonNumber(lean_object*, lean_object*);
 lean_object* l_Lean_JsonNumber_ltProp;
@@ -172,7 +172,6 @@ uint8_t lean_int_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjVal_x3f(lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_JsonNumber_normalize___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_isNull_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Int_Int_pow(lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjVal_x3f___boxed(lean_object*, lean_object*);
 lean_object* lean_nat_to_int(lean_object*);
 lean_object* l_Lean_JsonNumber_instCoeNatJsonNumber;
@@ -180,6 +179,7 @@ lean_object* l_Lean_JsonNumber_instDecidableLt___boxed(lean_object*, lean_object
 lean_object* l_Lean_JsonNumber_instCoeNatJsonNumber___closed__1;
 extern lean_object* l_Lean_Parser_Tactic_tactic_xb7_x2e_____closed__5;
 uint8_t lean_string_dec_lt(lean_object*, lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l___private_Lean_Data_Json_Basic_0__Lean_decEqJsonNumber____x40_Lean_Data_Json_Basic___hyg_22____boxed(lean_object*, lean_object*);
@@ -433,7 +433,7 @@ static lean_object* _init_l_Lean_JsonNumber_normalize___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = lean_int_neg(x_1);
 return x_2;
 }
@@ -513,7 +513,7 @@ return x_19;
 else
 {
 lean_object* x_20; lean_object* x_21; 
-x_20 = l_Int_Int_pow___closed__1;
+x_20 = l_Int_pow___closed__1;
 x_21 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_21, 0, x_20);
 lean_ctor_set(x_21, 1, x_17);
@@ -643,7 +643,7 @@ if (x_16 == 0)
 {
 lean_object* x_17; lean_object* x_18; 
 lean_dec(x_3);
-x_17 = l_Int_Int_pow___closed__1;
+x_17 = l_Int_pow___closed__1;
 lean_ctor_set(x_1, 0, x_17);
 x_18 = lean_apply_1(x_4, x_1);
 return x_18;
@@ -661,7 +661,7 @@ if (x_22 == 0)
 {
 lean_object* x_23; lean_object* x_24; 
 lean_dec(x_3);
-x_23 = l_Int_Int_pow___closed__1;
+x_23 = l_Int_pow___closed__1;
 lean_ctor_set(x_1, 0, x_23);
 x_24 = lean_apply_1(x_4, x_1);
 return x_24;
@@ -687,7 +687,7 @@ if (x_27 == 0)
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; 
 lean_dec(x_3);
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_29, 0, x_28);
 lean_ctor_set(x_29, 1, x_6);
@@ -707,7 +707,7 @@ if (x_34 == 0)
 {
 lean_object* x_35; lean_object* x_36; lean_object* x_37; 
 lean_dec(x_3);
-x_35 = l_Int_Int_pow___closed__1;
+x_35 = l_Int_pow___closed__1;
 x_36 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_36, 0, x_35);
 lean_ctor_set(x_36, 1, x_6);
@@ -3135,7 +3135,7 @@ x_24 = lean_nat_sub(x_3, x_23);
 lean_dec(x_23);
 lean_dec(x_3);
 x_25 = l_Lean_JsonNumber_toString___closed__1;
-x_26 = l_Int_Int_pow(x_25, x_24);
+x_26 = l_Int_pow(x_25, x_24);
 lean_dec(x_24);
 x_27 = lean_int_div(x_17, x_26);
 x_28 = l_Int_repr(x_27);
diff --git a/stage0/stdlib/Lean/Data/Json/Parser.c b/stage0/stdlib/Lean/Data/Json/Parser.c
index d6fc4010e9..5d53fa429d 100644
--- a/stage0/stdlib/Lean/Data/Json/Parser.c
+++ b/stage0/stdlib/Lean/Data/Json/Parser.c
@@ -52,7 +52,6 @@ lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_Json_Parser_anyCore(lean_object*);
 lean_object* l_Lean_Quickparse_instMonadQuickparse___closed__2;
 lean_object* l_Lean_Json_Parser_escapedChar___boxed__const__6;
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Json_Parser_escapedChar___boxed__const__2;
 lean_object* l_Lean_Quickparse_expect(lean_object*, lean_object*);
 lean_object* l_Lean_Json_Parser_anyCore___rarg___closed__6;
@@ -169,6 +168,7 @@ lean_object* l_Lean_Json_Parser_escapedChar_match__1___rarg___boxed(lean_object*
 lean_object* l_Lean_Json_Parser_natNonZero(lean_object*);
 lean_object* l_Lean_Json_Parser_num___lambda__5___closed__2___boxed__const__1;
 lean_object* l_Lean_Quickparse_pure___rarg(lean_object*, lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 lean_object* l_Char_ofNat(lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -3555,7 +3555,7 @@ x_8 = x_5 == x_7;
 if (x_8 == 0)
 {
 lean_object* x_9; lean_object* x_10; 
-x_9 = l_Int_Int_pow___closed__1;
+x_9 = l_Int_pow___closed__1;
 x_10 = lean_apply_2(x_6, x_9, x_1);
 return x_10;
 }
diff --git a/stage0/stdlib/Lean/Data/Lsp/Diagnostics.c b/stage0/stdlib/Lean/Data/Lsp/Diagnostics.c
index 5110a70505..bc08f23536 100644
--- a/stage0/stdlib/Lean/Data/Lsp/Diagnostics.c
+++ b/stage0/stdlib/Lean/Data/Lsp/Diagnostics.c
@@ -81,7 +81,6 @@ lean_object* l___private_Lean_Data_Lsp_Diagnostics_0__Lean_Lsp_beqPublishDiagnos
 lean_object* l_Lean_Lsp_instToJsonDiagnosticSeverity___closed__10;
 lean_object* l___private_Lean_Data_Lsp_Basic_0__Lean_Lsp_fromJsonLocation____x40_Lean_Data_Lsp_Basic___hyg_611_(lean_object*);
 lean_object* l_Lean_Lsp_instFromJsonDiagnosticSeverity(lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Lsp_instFromJsonDiagnosticRelatedInformation;
 extern lean_object* l_Lean_JsonRpc_instToJsonMessage___closed__10;
 lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_Diagnostics_0__Lean_Lsp_toJsonDiagnostic____x40_Lean_Data_Lsp_Diagnostics___hyg_794____spec__5(lean_object*, lean_object*);
@@ -255,6 +254,7 @@ lean_object* l_Lean_Lsp_instFromJsonDiagnosticSeverity_match__1___rarg(lean_obje
 lean_object* l_Lean_Lsp_instFromJsonDiagnosticSeverity_match__1(lean_object*);
 lean_object* l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Data_Lsp_Diagnostics_0__Lean_Lsp_beqDiagnostic____x40_Lean_Data_Lsp_Diagnostics___hyg_649____spec__6___boxed(lean_object*, lean_object*);
 uint8_t l___private_Lean_Data_Lsp_Diagnostics_0__Lean_Lsp_beqPublishDiagnosticsParams____x40_Lean_Data_Lsp_Diagnostics___hyg_1026_(lean_object*, lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Data_Lsp_Diagnostics_0__Lean_Lsp_fromJsonPublishDiagnosticsParams____x40_Lean_Data_Lsp_Diagnostics___hyg_1139____spec__3(size_t, size_t, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -808,7 +808,7 @@ static lean_object* _init_l_Lean_Lsp_instToJsonDiagnosticSeverity___closed__1()
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = lean_unsigned_to_nat(0u);
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
diff --git a/stage0/stdlib/Lean/Data/Lsp/LanguageFeatures.c b/stage0/stdlib/Lean/Data/Lsp/LanguageFeatures.c
index 206b580090..05793a0cb4 100644
--- a/stage0/stdlib/Lean/Data/Lsp/LanguageFeatures.c
+++ b/stage0/stdlib/Lean/Data/Lsp/LanguageFeatures.c
@@ -110,7 +110,6 @@ lean_object* l___private_Lean_Data_Lsp_LanguageFeatures_0__Lean_Lsp_fromJsonComp
 lean_object* l_Lean_Lsp_instToJsonSymbolKind___closed__5;
 lean_object* l_Lean_Lsp_instFromJsonDocumentHighlightParams;
 lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_LanguageFeatures_0__Lean_Lsp_fromJsonSemanticTokens____x40_Lean_Data_Lsp_LanguageFeatures___hyg_1873____spec__1___boxed(lean_object*, lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Lsp_instToJsonSymbolKind___closed__18;
 lean_object* l_Lean_Lsp_instToJsonSymbolKind___closed__15;
 lean_object* l___private_Lean_Data_Lsp_LanguageFeatures_0__Lean_Lsp_toJsonCompletionOptions____x40_Lean_Data_Lsp_LanguageFeatures___hyg_100_(lean_object*);
@@ -336,6 +335,7 @@ lean_object* l_Lean_Lsp_instToJsonDocumentSymbol_go_match__1___rarg(lean_object*
 lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_LanguageFeatures_0__Lean_Lsp_fromJsonSemanticTokensLegend____x40_Lean_Data_Lsp_LanguageFeatures___hyg_1488____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Data_Lsp_LanguageFeatures_0__Lean_Lsp_toJsonDocumentSymbolAux____x40_Lean_Data_Lsp_LanguageFeatures___hyg_1291____spec__2___rarg(lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Lean_Lsp_SemanticTokenType_names___closed__2;
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Lean_Lsp_instFromJsonCompletionList___closed__1;
 lean_object* l___private_Lean_Data_Lsp_LanguageFeatures_0__Lean_Lsp_fromJsonCompletionList____x40_Lean_Data_Lsp_LanguageFeatures___hyg_284____closed__2;
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Data_Lsp_LanguageFeatures_0__Lean_Lsp_toJsonSemanticTokens____x40_Lean_Data_Lsp_LanguageFeatures___hyg_1904____spec__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -2427,7 +2427,7 @@ static lean_object* _init_l_Lean_Lsp_instToJsonDocumentHighlightKind___closed__1
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = lean_unsigned_to_nat(0u);
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
diff --git a/stage0/stdlib/Lean/Data/Lsp/TextSync.c b/stage0/stdlib/Lean/Data/Lsp/TextSync.c
index 6805917608..40638a7fe6 100644
--- a/stage0/stdlib/Lean/Data/Lsp/TextSync.c
+++ b/stage0/stdlib/Lean/Data/Lsp/TextSync.c
@@ -59,7 +59,6 @@ lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_Basic_0__L
 lean_object* l___private_Lean_Data_Lsp_Basic_0__Lean_Lsp_toJsonTextDocumentItem____x40_Lean_Data_Lsp_Basic___hyg_1355_(lean_object*);
 extern lean_object* l___private_Lean_Data_Lsp_Basic_0__Lean_Lsp_toJsonTextDocumentRegistrationOptions____x40_Lean_Data_Lsp_Basic___hyg_1797____closed__1;
 lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_fromJsonDidChangeTextDocumentParams____x40_Lean_Data_Lsp_TextSync___hyg_376____spec__1(lean_object*, lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l___private_Lean_Data_Lsp_Basic_0__Lean_Lsp_fromJsonTextDocumentItem____x40_Lean_Data_Lsp_Basic___hyg_1407_(lean_object*);
 lean_object* l___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_toJsonTextDocumentSyncOptions____x40_Lean_Data_Lsp_TextSync___hyg_600____closed__6;
 lean_object* l_Lean_Lsp_instToJsonDidCloseTextDocumentParams;
@@ -136,6 +135,7 @@ lean_object* l_Lean_Lsp_TextDocumentChangeRegistrationOptions_documentSelector_x
 lean_object* l_Lean_Lsp_instFromJsonSaveOptions;
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_fromJsonDidChangeTextDocumentParams____x40_Lean_Data_Lsp_TextSync___hyg_376____spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_fromJsonTextDocumentSyncOptions____x40_Lean_Data_Lsp_TextSync___hyg_656____spec__1(lean_object*, lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Lean_Lsp_TextDocumentContentChangeEvent_hasToJson_match__1(lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_fromJsonDidChangeTextDocumentParams____x40_Lean_Data_Lsp_TextSync___hyg_376____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_instToJsonTextDocumentSyncOptions;
@@ -405,7 +405,7 @@ static lean_object* _init_l_Lean_Lsp_instToJsonTextDocumentSyncKind___closed__3(
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = lean_unsigned_to_nat(0u);
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
diff --git a/stage0/stdlib/Lean/Data/Options.c b/stage0/stdlib/Lean/Data/Options.c
index 37d64f571f..ab46780d29 100644
--- a/stage0/stdlib/Lean/Data/Options.c
+++ b/stage0/stdlib/Lean/Data/Options.c
@@ -87,7 +87,6 @@ uint8_t l_Lean_KVMap_getBool(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_setOptionFromString_match__4(lean_object*);
 lean_object* l_Lean_instMonadOptions___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Name_toString(lean_object*, uint8_t);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Option_myMacro____x40_Lean_Data_Options___hyg_979_(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedDataValue___closed__1;
 lean_object* l_Lean_Option_myMacro____x40_Lean_Data_Options___hyg_979____closed__19;
@@ -105,6 +104,7 @@ uint8_t l_Lean_KVMap_contains(lean_object*, lean_object*);
 lean_object* l_Lean_Options_empty;
 extern lean_object* l_Array_forInUnsafe_loop___at___private_Init_NotationExtra_0__Lean_mkHintBody___spec__1___closed__3;
 lean_object* l_Lean_Option_myMacro____x40_Lean_Data_Options___hyg_979____closed__4;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_Option_myMacro____x40_Lean_Data_Options___hyg_979____closed__8;
 lean_object* l_Lean_Option_myMacro____x40_Lean_Data_Options___hyg_979____closed__17;
 extern lean_object* l_Lean_Parser_Syntax_addPrec___closed__10;
@@ -2381,7 +2381,7 @@ lean_ctor_set(x_37, 0, x_36);
 lean_ctor_set(x_37, 1, x_35);
 x_38 = lean_array_push(x_33, x_22);
 x_39 = lean_array_push(x_38, x_37);
-x_40 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_40 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_41 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_41, 0, x_40);
 lean_ctor_set(x_41, 1, x_39);
@@ -2566,7 +2566,7 @@ lean_ctor_set(x_135, 0, x_134);
 lean_ctor_set(x_135, 1, x_133);
 x_136 = lean_array_push(x_131, x_120);
 x_137 = lean_array_push(x_136, x_135);
-x_138 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_138 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_139 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_139, 0, x_138);
 lean_ctor_set(x_139, 1, x_137);
diff --git a/stage0/stdlib/Lean/Declaration.c b/stage0/stdlib/Lean/Declaration.c
index b2637d7fdc..df1b9d7ec2 100644
--- a/stage0/stdlib/Lean/Declaration.c
+++ b/stage0/stdlib/Lean/Declaration.c
@@ -57,7 +57,6 @@ lean_object* l_Lean_ConstantInfo_value_x21___closed__1;
 lean_object* l_Lean_instInhabitedDefinitionVal___closed__1;
 lean_object* l_Lean_ConstantInfo_value_x21___boxed(lean_object*);
 lean_object* l_Lean_instBEqDefinitionSafety;
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_249____closed__6;
 lean_object* l_Lean_Declaration_foldExprM___rarg___lambda__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_InductiveVal_isRecEx___boxed(lean_object*);
@@ -218,6 +217,7 @@ lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Le
 uint8_t l_Lean_ReducibilityHints_lt(lean_object*, lean_object*);
 lean_object* l_Lean_instInhabitedConstructorVal___closed__1;
 uint8_t l_Lean_instInhabitedQuotKind;
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_249____closed__4;
 lean_object* l_Repr_addAppParen(lean_object*, lean_object*);
 lean_object* l_Lean_instInhabitedRecursorRule___closed__1;
@@ -838,7 +838,7 @@ static lean_object* _init_l___private_Lean_Declaration_0__Lean_reprDefinitionSaf
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_249____closed__2;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -904,7 +904,7 @@ static lean_object* _init_l___private_Lean_Declaration_0__Lean_reprDefinitionSaf
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_249____closed__8;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -970,7 +970,7 @@ static lean_object* _init_l___private_Lean_Declaration_0__Lean_reprDefinitionSaf
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_249____closed__14;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
diff --git a/stage0/stdlib/Lean/Elab/App.c b/stage0/stdlib/Lean/Elab/App.c
index c0eea7a0f4..f7731ee47c 100644
--- a/stage0/stdlib/Lean/Elab/App.c
+++ b/stage0/stdlib/Lean/Elab/App.c
@@ -16649,7 +16649,7 @@ return x_42;
 }
 else
 {
-uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
 x_43 = lean_ctor_get_uint8(x_22, 0);
 x_44 = lean_ctor_get_uint8(x_22, 1);
 x_45 = lean_ctor_get_uint8(x_22, 2);
@@ -16658,65 +16658,67 @@ x_47 = lean_ctor_get_uint8(x_22, 4);
 x_48 = lean_ctor_get_uint8(x_22, 6);
 x_49 = lean_ctor_get_uint8(x_22, 7);
 x_50 = lean_ctor_get_uint8(x_22, 8);
+x_51 = lean_ctor_get_uint8(x_22, 9);
 lean_dec(x_22);
-x_51 = 2;
-x_52 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_52, 0, x_43);
-lean_ctor_set_uint8(x_52, 1, x_44);
-lean_ctor_set_uint8(x_52, 2, x_45);
-lean_ctor_set_uint8(x_52, 3, x_46);
-lean_ctor_set_uint8(x_52, 4, x_47);
-lean_ctor_set_uint8(x_52, 5, x_51);
-lean_ctor_set_uint8(x_52, 6, x_48);
-lean_ctor_set_uint8(x_52, 7, x_49);
-lean_ctor_set_uint8(x_52, 8, x_50);
-x_53 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_23);
-lean_ctor_set(x_53, 2, x_24);
-lean_ctor_set(x_53, 3, x_25);
+x_52 = 2;
+x_53 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_53, 0, x_43);
+lean_ctor_set_uint8(x_53, 1, x_44);
+lean_ctor_set_uint8(x_53, 2, x_45);
+lean_ctor_set_uint8(x_53, 3, x_46);
+lean_ctor_set_uint8(x_53, 4, x_47);
+lean_ctor_set_uint8(x_53, 5, x_52);
+lean_ctor_set_uint8(x_53, 6, x_48);
+lean_ctor_set_uint8(x_53, 7, x_49);
+lean_ctor_set_uint8(x_53, 8, x_50);
+lean_ctor_set_uint8(x_53, 9, x_51);
+x_54 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_54, 0, x_53);
+lean_ctor_set(x_54, 1, x_23);
+lean_ctor_set(x_54, 2, x_24);
+lean_ctor_set(x_54, 3, x_25);
 lean_inc(x_20);
 lean_inc(x_19);
 lean_inc(x_18);
 lean_inc(x_7);
-x_54 = l_Lean_Meta_whnf(x_7, x_53, x_18, x_19, x_20, x_21);
-if (lean_obj_tag(x_54) == 0)
+x_55 = l_Lean_Meta_whnf(x_7, x_54, x_18, x_19, x_20, x_21);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; 
-x_55 = lean_ctor_get(x_54, 0);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_54, 1);
+lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+x_56 = lean_ctor_get(x_55, 0);
 lean_inc(x_56);
-lean_dec(x_54);
-x_57 = l_Lean_Expr_consumeMData(x_55);
+x_57 = lean_ctor_get(x_55, 1);
+lean_inc(x_57);
 lean_dec(x_55);
-x_58 = l_Lean_Expr_isAppOf(x_57, x_11);
-lean_dec(x_57);
-if (x_58 == 0)
+x_58 = l_Lean_Expr_consumeMData(x_56);
+lean_dec(x_56);
+x_59 = l_Lean_Expr_isAppOf(x_58, x_11);
+lean_dec(x_58);
+if (x_59 == 0)
 {
-lean_object* x_59; lean_object* x_60; 
-x_59 = lean_box(0);
-x_60 = l_Std_Range_forIn_loop___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__2___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_12, x_13, x_59, x_15, x_16, x_17, x_18, x_19, x_20, x_56);
+lean_object* x_60; lean_object* x_61; 
+x_60 = lean_box(0);
+x_61 = l_Std_Range_forIn_loop___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__2___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_12, x_13, x_60, x_15, x_16, x_17, x_18, x_19, x_20, x_57);
 lean_dec(x_20);
 lean_dec(x_19);
 lean_dec(x_18);
-return x_60;
+return x_61;
 }
 else
 {
-uint8_t x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = 1;
-x_62 = lean_box(0);
-x_63 = l_Std_Range_forIn_loop___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__2___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_61, x_13, x_62, x_15, x_16, x_17, x_18, x_19, x_20, x_56);
+uint8_t x_62; lean_object* x_63; lean_object* x_64; 
+x_62 = 1;
+x_63 = lean_box(0);
+x_64 = l_Std_Range_forIn_loop___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__2___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_62, x_13, x_63, x_15, x_16, x_17, x_18, x_19, x_20, x_57);
 lean_dec(x_20);
 lean_dec(x_19);
 lean_dec(x_18);
-return x_63;
+return x_64;
 }
 }
 else
 {
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
 lean_dec(x_20);
 lean_dec(x_19);
 lean_dec(x_18);
@@ -16731,38 +16733,38 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_64 = lean_ctor_get(x_54, 0);
-lean_inc(x_64);
-x_65 = lean_ctor_get(x_54, 1);
+x_65 = lean_ctor_get(x_55, 0);
 lean_inc(x_65);
-if (lean_is_exclusive(x_54)) {
- lean_ctor_release(x_54, 0);
- lean_ctor_release(x_54, 1);
- x_66 = x_54;
+x_66 = lean_ctor_get(x_55, 1);
+lean_inc(x_66);
+if (lean_is_exclusive(x_55)) {
+ lean_ctor_release(x_55, 0);
+ lean_ctor_release(x_55, 1);
+ x_67 = x_55;
 } else {
- lean_dec_ref(x_54);
- x_66 = lean_box(0);
+ lean_dec_ref(x_55);
+ x_67 = lean_box(0);
 }
-if (lean_is_scalar(x_66)) {
- x_67 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_67)) {
+ x_68 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_67 = x_66;
+ x_68 = x_67;
 }
-lean_ctor_set(x_67, 0, x_64);
-lean_ctor_set(x_67, 1, x_65);
-return x_67;
+lean_ctor_set(x_68, 0, x_65);
+lean_ctor_set(x_68, 1, x_66);
+return x_68;
 }
 }
 }
 else
 {
-lean_object* x_68; lean_object* x_69; 
-x_68 = lean_box(0);
-x_69 = l_Std_Range_forIn_loop___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__2___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_12, x_13, x_68, x_15, x_16, x_17, x_18, x_19, x_20, x_21);
+lean_object* x_69; lean_object* x_70; 
+x_69 = lean_box(0);
+x_70 = l_Std_Range_forIn_loop___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__2___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_12, x_13, x_69, x_15, x_16, x_17, x_18, x_19, x_20, x_21);
 lean_dec(x_20);
 lean_dec(x_19);
 lean_dec(x_18);
-return x_69;
+return x_70;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Elab/Binders.c b/stage0/stdlib/Lean/Elab/Binders.c
index ac9317da1b..f62e55e888 100644
--- a/stage0/stdlib/Lean/Elab/Binders.c
+++ b/stage0/stdlib/Lean/Elab/Binders.c
@@ -248,7 +248,6 @@ lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*, lean_object*, uint8_t, uint
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__8;
 extern lean_object* l_Lean_Parser_Syntax_addPrec___closed__5;
 lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_5600_(lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1102_(lean_object*);
 lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__20;
 lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandBinderModifier___closed__8;
@@ -318,6 +317,7 @@ extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
 uint8_t l_Array_isEmpty___rarg(lean_object*);
 extern lean_object* l_Lean_instInhabitedSyntax;
 lean_object* l_Lean_Meta_getLocalInstances(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_FunBinders_propagateExpectedType_match__2(lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14569____closed__12;
@@ -24433,7 +24433,7 @@ lean_ctor_set(x_109, 1, x_108);
 x_110 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_111 = lean_array_push(x_110, x_109);
 x_112 = lean_array_push(x_111, x_89);
-x_113 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_113 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_114 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_114, 0, x_113);
 lean_ctor_set(x_114, 1, x_112);
diff --git a/stage0/stdlib/Lean/Elab/BuiltinNotation.c b/stage0/stdlib/Lean/Elab/BuiltinNotation.c
index 4e2a8876d6..86ae90dadc 100644
--- a/stage0/stdlib/Lean/Elab/BuiltinNotation.c
+++ b/stage0/stdlib/Lean/Elab/BuiltinNotation.c
@@ -241,7 +241,6 @@ lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*, lean_object*, uint8_t, uint
 lean_object* l_Lean_Elab_Term_expandDbgTrace___closed__5;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__8;
 extern lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__43;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Term_elabCDotFunctionAlias_x3f_match__2(lean_object*);
 lean_object* l_Lean_Elab_getRefPosition___at_Lean_Elab_Term_elabPanic___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__4;
@@ -305,6 +304,7 @@ lean_object* l_Lean_Elab_Term_elabLeadingParserMacro___lambda__1___boxed(lean_ob
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
 lean_object* l_Lean_Elab_Term_elabTrailingParserMacro___lambda__2___boxed(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_instInhabitedSyntax;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__7;
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Elab_Term_elabAnonymousCtor___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -326,6 +326,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabSorry___closed__1;
 extern lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__13;
 lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__10;
 extern lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__2;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_object* l_Lean_Elab_Term_elabSubst___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*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabCDotFunctionAlias_x3f_match__1(lean_object*);
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
@@ -367,7 +368,6 @@ lean_object* l_Lean_Elab_Term_elabTrailingParserMacro___lambda__1(lean_object*,
 lean_object* l_Lean_Elab_Term_expandParen(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_BuiltinNotation_0__Lean_Elab_Term_elabTParserMacroAux___closed__7;
 lean_object* l___regBuiltin_Lean_Elab_Term_expandShow(lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
 extern lean_object* l_Lean_Elab_macroAttribute;
 lean_object* lean_environment_main_module(lean_object*);
 extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17663____closed__5;
@@ -2309,7 +2309,7 @@ lean_ctor_set(x_99, 1, x_98);
 x_100 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_101 = lean_array_push(x_100, x_99);
 x_102 = lean_array_push(x_101, x_9);
-x_103 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_103 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_104 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_104, 0, x_103);
 lean_ctor_set(x_104, 1, x_102);
@@ -2382,7 +2382,7 @@ lean_ctor_set(x_139, 1, x_138);
 x_140 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_141 = lean_array_push(x_140, x_139);
 x_142 = lean_array_push(x_141, x_9);
-x_143 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_143 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_144 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_144, 0, x_143);
 lean_ctor_set(x_144, 1, x_142);
@@ -2690,7 +2690,7 @@ lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean
 x_44 = lean_ctor_get(x_3, 0);
 lean_inc(x_44);
 lean_dec(x_3);
-x_45 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_45 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_46 = lean_name_mk_string(x_8, x_45);
 x_47 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_48 = lean_alloc_ctor(2, 2, 0);
@@ -2794,7 +2794,7 @@ lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean
 x_95 = lean_ctor_get(x_3, 0);
 lean_inc(x_95);
 lean_dec(x_3);
-x_96 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_96 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_97 = lean_name_mk_string(x_8, x_96);
 x_98 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_99 = lean_alloc_ctor(2, 2, 0);
@@ -2986,7 +2986,7 @@ lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean
 x_46 = lean_ctor_get(x_5, 0);
 lean_inc(x_46);
 lean_dec(x_5);
-x_47 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_47 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_48 = lean_name_mk_string(x_3, x_47);
 x_49 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_50 = lean_alloc_ctor(2, 2, 0);
@@ -3097,7 +3097,7 @@ lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103;
 x_100 = lean_ctor_get(x_5, 0);
 lean_inc(x_100);
 lean_dec(x_5);
-x_101 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_101 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_102 = lean_name_mk_string(x_3, x_101);
 x_103 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_104 = lean_alloc_ctor(2, 2, 0);
@@ -3280,7 +3280,7 @@ lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean
 x_46 = lean_ctor_get(x_3, 0);
 lean_inc(x_46);
 lean_dec(x_3);
-x_47 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_47 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_48 = lean_name_mk_string(x_8, x_47);
 x_49 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_50 = lean_alloc_ctor(2, 2, 0);
@@ -3390,7 +3390,7 @@ lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103;
 x_100 = lean_ctor_get(x_3, 0);
 lean_inc(x_100);
 lean_dec(x_3);
-x_101 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_101 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_102 = lean_name_mk_string(x_8, x_101);
 x_103 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_104 = lean_alloc_ctor(2, 2, 0);
@@ -3565,7 +3565,7 @@ lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean
 x_50 = lean_ctor_get(x_5, 0);
 lean_inc(x_50);
 lean_dec(x_5);
-x_51 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_51 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_52 = lean_name_mk_string(x_3, x_51);
 x_53 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_54 = lean_alloc_ctor(2, 2, 0);
@@ -3684,7 +3684,7 @@ lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112;
 x_109 = lean_ctor_get(x_5, 0);
 lean_inc(x_109);
 lean_dec(x_5);
-x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_111 = lean_name_mk_string(x_3, x_110);
 x_112 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 x_113 = lean_alloc_ctor(2, 2, 0);
@@ -3982,7 +3982,7 @@ else
 lean_object* x_62; lean_object* x_63; uint8_t x_64; 
 x_62 = l_Lean_Syntax_getArg(x_57, x_16);
 lean_dec(x_57);
-x_63 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_63 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_inc(x_62);
 x_64 = l_Lean_Syntax_isOfKind(x_62, x_63);
 if (x_64 == 0)
@@ -4061,7 +4061,7 @@ else
 lean_object* x_83; lean_object* x_84; uint8_t x_85; 
 x_83 = l_Lean_Syntax_getArg(x_78, x_16);
 lean_dec(x_78);
-x_84 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_84 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_inc(x_83);
 x_85 = l_Lean_Syntax_isOfKind(x_83, x_84);
 if (x_85 == 0)
@@ -4163,7 +4163,7 @@ else
 lean_object* x_109; lean_object* x_110; uint8_t x_111; 
 x_109 = l_Lean_Syntax_getArg(x_104, x_16);
 lean_dec(x_104);
-x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_inc(x_109);
 x_111 = l_Lean_Syntax_isOfKind(x_109, x_110);
 if (x_111 == 0)
@@ -4242,7 +4242,7 @@ else
 lean_object* x_130; lean_object* x_131; uint8_t x_132; 
 x_130 = l_Lean_Syntax_getArg(x_125, x_16);
 lean_dec(x_125);
-x_131 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_131 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_inc(x_130);
 x_132 = l_Lean_Syntax_isOfKind(x_130, x_131);
 if (x_132 == 0)
@@ -4462,7 +4462,7 @@ x_21 = lean_name_mk_string(x_2, x_20);
 x_22 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__2;
 lean_inc(x_2);
 x_23 = lean_name_mk_string(x_2, x_22);
-x_24 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_24 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_25 = lean_name_mk_string(x_2, x_24);
 x_26 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_inc(x_14);
@@ -4631,7 +4631,7 @@ x_18 = lean_name_mk_string(x_2, x_17);
 x_19 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__2;
 lean_inc(x_2);
 x_20 = lean_name_mk_string(x_2, x_19);
-x_21 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_21 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_22 = lean_name_mk_string(x_2, x_21);
 x_23 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_inc(x_13);
@@ -4745,7 +4745,7 @@ x_76 = lean_name_mk_string(x_2, x_75);
 x_77 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__2;
 lean_inc(x_2);
 x_78 = lean_name_mk_string(x_2, x_77);
-x_79 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_79 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_80 = lean_name_mk_string(x_2, x_79);
 x_81 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_inc(x_70);
diff --git a/stage0/stdlib/Lean/Elab/Command.c b/stage0/stdlib/Lean/Elab/Command.c
index d9c88756da..f60c37a715 100644
--- a/stage0/stdlib/Lean/Elab/Command.c
+++ b/stage0/stdlib/Lean/Elab/Command.c
@@ -14446,7 +14446,7 @@ uint8_t x_1; uint8_t x_2; uint8_t x_3; lean_object* x_4;
 x_1 = 1;
 x_2 = 0;
 x_3 = 1;
-x_4 = lean_alloc_ctor(0, 0, 9);
+x_4 = lean_alloc_ctor(0, 0, 10);
 lean_ctor_set_uint8(x_4, 0, x_1);
 lean_ctor_set_uint8(x_4, 1, x_1);
 lean_ctor_set_uint8(x_4, 2, x_1);
@@ -14456,6 +14456,7 @@ lean_ctor_set_uint8(x_4, 5, x_3);
 lean_ctor_set_uint8(x_4, 6, x_1);
 lean_ctor_set_uint8(x_4, 7, x_2);
 lean_ctor_set_uint8(x_4, 8, x_1);
+lean_ctor_set_uint8(x_4, 9, x_1);
 return x_4;
 }
 }
@@ -26735,7 +26736,7 @@ return x_43;
 }
 else
 {
-uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; 
+uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; 
 x_44 = lean_ctor_get_uint8(x_26, 0);
 x_45 = lean_ctor_get_uint8(x_26, 1);
 x_46 = lean_ctor_get_uint8(x_26, 2);
@@ -26744,91 +26745,94 @@ x_48 = lean_ctor_get_uint8(x_26, 4);
 x_49 = lean_ctor_get_uint8(x_26, 6);
 x_50 = lean_ctor_get_uint8(x_26, 7);
 x_51 = lean_ctor_get_uint8(x_26, 8);
+x_52 = lean_ctor_get_uint8(x_26, 9);
 lean_dec(x_26);
-x_52 = 0;
-x_53 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_53, 0, x_44);
-lean_ctor_set_uint8(x_53, 1, x_45);
-lean_ctor_set_uint8(x_53, 2, x_46);
-lean_ctor_set_uint8(x_53, 3, x_47);
-lean_ctor_set_uint8(x_53, 4, x_48);
-lean_ctor_set_uint8(x_53, 5, x_52);
-lean_ctor_set_uint8(x_53, 6, x_49);
-lean_ctor_set_uint8(x_53, 7, x_50);
-lean_ctor_set_uint8(x_53, 8, x_51);
-x_54 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_54, 0, x_53);
-lean_ctor_set(x_54, 1, x_27);
-lean_ctor_set(x_54, 2, x_28);
-lean_ctor_set(x_54, 3, x_29);
-x_55 = 1;
+x_53 = 0;
+x_54 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_54, 0, x_44);
+lean_ctor_set_uint8(x_54, 1, x_45);
+lean_ctor_set_uint8(x_54, 2, x_46);
+lean_ctor_set_uint8(x_54, 3, x_47);
+lean_ctor_set_uint8(x_54, 4, x_48);
+lean_ctor_set_uint8(x_54, 5, x_53);
+lean_ctor_set_uint8(x_54, 6, x_49);
+lean_ctor_set_uint8(x_54, 7, x_50);
+lean_ctor_set_uint8(x_54, 8, x_51);
+lean_ctor_set_uint8(x_54, 9, x_52);
+x_55 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_55, 0, x_54);
+lean_ctor_set(x_55, 1, x_27);
+lean_ctor_set(x_55, 2, x_28);
+lean_ctor_set(x_55, 3, x_29);
+x_56 = 1;
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-x_56 = l_Lean_Meta_reduce(x_21, x_55, x_10, x_10, x_54, x_6, x_7, x_8, x_20);
-if (lean_obj_tag(x_56) == 0)
+x_57 = l_Lean_Meta_reduce(x_21, x_56, x_10, x_10, x_55, x_6, x_7, x_8, x_20);
+if (lean_obj_tag(x_57) == 0)
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; lean_object* x_61; 
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_56, 1);
+lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; 
+x_58 = lean_ctor_get(x_57, 0);
 lean_inc(x_58);
-lean_dec(x_56);
-x_59 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_59, 0, x_57);
-x_60 = 0;
-x_61 = l_Lean_Elab_logAt___at_Lean_Elab_Term_traceAtCmdPos___spec__3(x_1, x_59, x_60, x_3, x_4, x_5, x_6, x_7, x_8, x_58);
+x_59 = lean_ctor_get(x_57, 1);
+lean_inc(x_59);
+lean_dec(x_57);
+x_60 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_60, 0, x_58);
+x_61 = 0;
+x_62 = l_Lean_Elab_logAt___at_Lean_Elab_Term_traceAtCmdPos___spec__3(x_1, x_60, x_61, x_3, x_4, x_5, x_6, x_7, x_8, x_59);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-return x_61;
+return x_62;
 }
 else
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
 lean_dec(x_7);
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_62 = lean_ctor_get(x_56, 0);
-lean_inc(x_62);
-x_63 = lean_ctor_get(x_56, 1);
+x_63 = lean_ctor_get(x_57, 0);
 lean_inc(x_63);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_64 = x_56;
+x_64 = lean_ctor_get(x_57, 1);
+lean_inc(x_64);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_65 = x_57;
 } else {
- lean_dec_ref(x_56);
- x_64 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_65 = lean_box(0);
 }
-if (lean_is_scalar(x_64)) {
- x_65 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_65)) {
+ x_66 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_65 = x_64;
+ x_66 = x_65;
 }
-lean_ctor_set(x_65, 0, x_62);
-lean_ctor_set(x_65, 1, x_63);
-return x_65;
+lean_ctor_set(x_66, 0, x_63);
+lean_ctor_set(x_66, 1, x_64);
+return x_66;
 }
 }
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; uint8_t x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; 
-x_66 = lean_ctor_get(x_7, 0);
-x_67 = lean_ctor_get(x_7, 1);
-x_68 = lean_ctor_get(x_7, 2);
-x_69 = lean_ctor_get(x_7, 3);
-x_70 = lean_ctor_get(x_7, 4);
-x_71 = lean_ctor_get(x_7, 5);
-x_72 = lean_ctor_get(x_7, 6);
-x_73 = lean_ctor_get(x_7, 7);
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; uint8_t x_88; uint8_t x_89; uint8_t x_90; lean_object* x_91; uint8_t x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; lean_object* x_96; 
+x_67 = lean_ctor_get(x_7, 0);
+x_68 = lean_ctor_get(x_7, 1);
+x_69 = lean_ctor_get(x_7, 2);
+x_70 = lean_ctor_get(x_7, 3);
+x_71 = lean_ctor_get(x_7, 4);
+x_72 = lean_ctor_get(x_7, 5);
+x_73 = lean_ctor_get(x_7, 6);
+x_74 = lean_ctor_get(x_7, 7);
+lean_inc(x_74);
 lean_inc(x_73);
 lean_inc(x_72);
 lean_inc(x_71);
@@ -26836,150 +26840,151 @@ lean_inc(x_70);
 lean_inc(x_69);
 lean_inc(x_68);
 lean_inc(x_67);
-lean_inc(x_66);
 lean_dec(x_7);
-x_74 = l_Lean_Meta_initFn____x40_Lean_Meta_WHNF___hyg_13____closed__2;
-x_75 = l_Lean_KVMap_setBool(x_66, x_74, x_10);
-x_76 = lean_alloc_ctor(0, 8, 0);
-lean_ctor_set(x_76, 0, x_75);
-lean_ctor_set(x_76, 1, x_67);
-lean_ctor_set(x_76, 2, x_68);
-lean_ctor_set(x_76, 3, x_69);
-lean_ctor_set(x_76, 4, x_70);
-lean_ctor_set(x_76, 5, x_71);
-lean_ctor_set(x_76, 6, x_72);
-lean_ctor_set(x_76, 7, x_73);
-x_77 = lean_ctor_get(x_5, 0);
-lean_inc(x_77);
-x_78 = lean_ctor_get(x_5, 1);
+x_75 = l_Lean_Meta_initFn____x40_Lean_Meta_WHNF___hyg_13____closed__2;
+x_76 = l_Lean_KVMap_setBool(x_67, x_75, x_10);
+x_77 = lean_alloc_ctor(0, 8, 0);
+lean_ctor_set(x_77, 0, x_76);
+lean_ctor_set(x_77, 1, x_68);
+lean_ctor_set(x_77, 2, x_69);
+lean_ctor_set(x_77, 3, x_70);
+lean_ctor_set(x_77, 4, x_71);
+lean_ctor_set(x_77, 5, x_72);
+lean_ctor_set(x_77, 6, x_73);
+lean_ctor_set(x_77, 7, x_74);
+x_78 = lean_ctor_get(x_5, 0);
 lean_inc(x_78);
-x_79 = lean_ctor_get(x_5, 2);
+x_79 = lean_ctor_get(x_5, 1);
 lean_inc(x_79);
-x_80 = lean_ctor_get(x_5, 3);
+x_80 = lean_ctor_get(x_5, 2);
 lean_inc(x_80);
-x_81 = lean_ctor_get_uint8(x_77, 0);
-x_82 = lean_ctor_get_uint8(x_77, 1);
-x_83 = lean_ctor_get_uint8(x_77, 2);
-x_84 = lean_ctor_get_uint8(x_77, 3);
-x_85 = lean_ctor_get_uint8(x_77, 4);
-x_86 = lean_ctor_get_uint8(x_77, 6);
-x_87 = lean_ctor_get_uint8(x_77, 7);
-x_88 = lean_ctor_get_uint8(x_77, 8);
-if (lean_is_exclusive(x_77)) {
- x_89 = x_77;
+x_81 = lean_ctor_get(x_5, 3);
+lean_inc(x_81);
+x_82 = lean_ctor_get_uint8(x_78, 0);
+x_83 = lean_ctor_get_uint8(x_78, 1);
+x_84 = lean_ctor_get_uint8(x_78, 2);
+x_85 = lean_ctor_get_uint8(x_78, 3);
+x_86 = lean_ctor_get_uint8(x_78, 4);
+x_87 = lean_ctor_get_uint8(x_78, 6);
+x_88 = lean_ctor_get_uint8(x_78, 7);
+x_89 = lean_ctor_get_uint8(x_78, 8);
+x_90 = lean_ctor_get_uint8(x_78, 9);
+if (lean_is_exclusive(x_78)) {
+ x_91 = x_78;
 } else {
- lean_dec_ref(x_77);
- x_89 = lean_box(0);
+ lean_dec_ref(x_78);
+ x_91 = lean_box(0);
 }
-x_90 = 0;
-if (lean_is_scalar(x_89)) {
- x_91 = lean_alloc_ctor(0, 0, 9);
+x_92 = 0;
+if (lean_is_scalar(x_91)) {
+ x_93 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_91 = x_89;
+ x_93 = x_91;
 }
-lean_ctor_set_uint8(x_91, 0, x_81);
-lean_ctor_set_uint8(x_91, 1, x_82);
-lean_ctor_set_uint8(x_91, 2, x_83);
-lean_ctor_set_uint8(x_91, 3, x_84);
-lean_ctor_set_uint8(x_91, 4, x_85);
-lean_ctor_set_uint8(x_91, 5, x_90);
-lean_ctor_set_uint8(x_91, 6, x_86);
-lean_ctor_set_uint8(x_91, 7, x_87);
-lean_ctor_set_uint8(x_91, 8, x_88);
-x_92 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_92, 0, x_91);
-lean_ctor_set(x_92, 1, x_78);
-lean_ctor_set(x_92, 2, x_79);
-lean_ctor_set(x_92, 3, x_80);
-x_93 = 1;
+lean_ctor_set_uint8(x_93, 0, x_82);
+lean_ctor_set_uint8(x_93, 1, x_83);
+lean_ctor_set_uint8(x_93, 2, x_84);
+lean_ctor_set_uint8(x_93, 3, x_85);
+lean_ctor_set_uint8(x_93, 4, x_86);
+lean_ctor_set_uint8(x_93, 5, x_92);
+lean_ctor_set_uint8(x_93, 6, x_87);
+lean_ctor_set_uint8(x_93, 7, x_88);
+lean_ctor_set_uint8(x_93, 8, x_89);
+lean_ctor_set_uint8(x_93, 9, x_90);
+x_94 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_94, 0, x_93);
+lean_ctor_set(x_94, 1, x_79);
+lean_ctor_set(x_94, 2, x_80);
+lean_ctor_set(x_94, 3, x_81);
+x_95 = 1;
 lean_inc(x_8);
-lean_inc(x_76);
+lean_inc(x_77);
 lean_inc(x_6);
-x_94 = l_Lean_Meta_reduce(x_21, x_93, x_10, x_10, x_92, x_6, x_76, x_8, x_20);
-if (lean_obj_tag(x_94) == 0)
+x_96 = l_Lean_Meta_reduce(x_21, x_95, x_10, x_10, x_94, x_6, x_77, x_8, x_20);
+if (lean_obj_tag(x_96) == 0)
 {
-lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_95 = lean_ctor_get(x_94, 0);
-lean_inc(x_95);
-x_96 = lean_ctor_get(x_94, 1);
-lean_inc(x_96);
-lean_dec(x_94);
-x_97 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_97, 0, x_95);
-x_98 = 0;
-x_99 = l_Lean_Elab_logAt___at_Lean_Elab_Term_traceAtCmdPos___spec__3(x_1, x_97, x_98, x_3, x_4, x_5, x_6, x_76, x_8, x_96);
+lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; lean_object* x_101; 
+x_97 = lean_ctor_get(x_96, 0);
+lean_inc(x_97);
+x_98 = lean_ctor_get(x_96, 1);
+lean_inc(x_98);
+lean_dec(x_96);
+x_99 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_99, 0, x_97);
+x_100 = 0;
+x_101 = l_Lean_Elab_logAt___at_Lean_Elab_Term_traceAtCmdPos___spec__3(x_1, x_99, x_100, x_3, x_4, x_5, x_6, x_77, x_8, x_98);
 lean_dec(x_8);
-lean_dec(x_76);
+lean_dec(x_77);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-return x_99;
+return x_101;
 }
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-lean_dec(x_76);
+lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; 
+lean_dec(x_77);
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_100 = lean_ctor_get(x_94, 0);
-lean_inc(x_100);
-x_101 = lean_ctor_get(x_94, 1);
-lean_inc(x_101);
-if (lean_is_exclusive(x_94)) {
- lean_ctor_release(x_94, 0);
- lean_ctor_release(x_94, 1);
- x_102 = x_94;
+x_102 = lean_ctor_get(x_96, 0);
+lean_inc(x_102);
+x_103 = lean_ctor_get(x_96, 1);
+lean_inc(x_103);
+if (lean_is_exclusive(x_96)) {
+ lean_ctor_release(x_96, 0);
+ lean_ctor_release(x_96, 1);
+ x_104 = x_96;
 } else {
- lean_dec_ref(x_94);
- x_102 = lean_box(0);
+ lean_dec_ref(x_96);
+ x_104 = lean_box(0);
 }
-if (lean_is_scalar(x_102)) {
- x_103 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_104)) {
+ x_105 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_103 = x_102;
+ x_105 = x_104;
 }
-lean_ctor_set(x_103, 0, x_100);
-lean_ctor_set(x_103, 1, x_101);
-return x_103;
+lean_ctor_set(x_105, 0, x_102);
+lean_ctor_set(x_105, 1, x_103);
+return x_105;
 }
 }
 }
 else
 {
-uint8_t x_104; 
+uint8_t x_106; 
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_104 = !lean_is_exclusive(x_14);
-if (x_104 == 0)
+x_106 = !lean_is_exclusive(x_14);
+if (x_106 == 0)
 {
 return x_14;
 }
 else
 {
-lean_object* x_105; lean_object* x_106; lean_object* x_107; 
-x_105 = lean_ctor_get(x_14, 0);
-x_106 = lean_ctor_get(x_14, 1);
-lean_inc(x_106);
-lean_inc(x_105);
+lean_object* x_107; lean_object* x_108; lean_object* x_109; 
+x_107 = lean_ctor_get(x_14, 0);
+x_108 = lean_ctor_get(x_14, 1);
+lean_inc(x_108);
+lean_inc(x_107);
 lean_dec(x_14);
-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;
+x_109 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_109, 0, x_107);
+lean_ctor_set(x_109, 1, x_108);
+return x_109;
 }
 }
 }
 else
 {
-uint8_t x_108; 
+uint8_t x_110; 
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -26987,23 +26992,23 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_108 = !lean_is_exclusive(x_12);
-if (x_108 == 0)
+x_110 = !lean_is_exclusive(x_12);
+if (x_110 == 0)
 {
 return x_12;
 }
 else
 {
-lean_object* x_109; lean_object* x_110; lean_object* x_111; 
-x_109 = lean_ctor_get(x_12, 0);
-x_110 = lean_ctor_get(x_12, 1);
-lean_inc(x_110);
-lean_inc(x_109);
+lean_object* x_111; lean_object* x_112; lean_object* x_113; 
+x_111 = lean_ctor_get(x_12, 0);
+x_112 = lean_ctor_get(x_12, 1);
+lean_inc(x_112);
+lean_inc(x_111);
 lean_dec(x_12);
-x_111 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_111, 0, x_109);
-lean_ctor_set(x_111, 1, x_110);
-return x_111;
+x_113 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_113, 0, x_111);
+lean_ctor_set(x_113, 1, x_112);
+return x_113;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Elab/Declaration.c b/stage0/stdlib/Lean/Elab/Declaration.c
index f9f1d2a89b..5c4bcb4d65 100644
--- a/stage0/stdlib/Lean/Elab/Declaration.c
+++ b/stage0/stdlib/Lean/Elab/Declaration.c
@@ -44,7 +44,6 @@ lean_object* l_Lean_Elab_Command_expandDeclIdNamespace_x3f(lean_object*);
 lean_object* l_Lean_Elab_resolveGlobalConstNoOverloadWithInfo___at_Lean_Elab_Term_elabDoubleQuotedName___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_liftTermElabM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Command_expandBuiltinInitialize___closed__1;
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_expandMutualNamespace_match__1(lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_Declaration_0__Lean_Elab_Command_inductiveSyntaxToView___spec__3___lambda__2___closed__1;
@@ -61,6 +60,7 @@ lean_object* l_Lean_Elab_Command_checkValidCtorModifier___at___private_Lean_Elab
 lean_object* l_Lean_Syntax_getIdAt(lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_Command_commandElabAttribute;
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 lean_object* l_Lean_Elab_Command_checkValidCtorModifier___at___private_Lean_Elab_Declaration_0__Lean_Elab_Command_inductiveSyntaxToView___spec__1___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabAttr_match__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Declaration_0__Lean_Elab_Command_inductiveSyntaxToView_match__1___rarg(lean_object*, lean_object*);
@@ -100,6 +100,7 @@ lean_object* l_Lean_Elab_Term_applyAttributesAt(lean_object*, lean_object*, uint
 extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_351____closed__16;
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__10;
 lean_object* l_Lean_Elab_Command_expandMutualElement_match__1(lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
 lean_object* l_Lean_Elab_Command_getLevelNames___rarg(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Command_elabMutual(lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
@@ -159,7 +160,6 @@ lean_object* l_Lean_replaceRef(lean_object*, lean_object*);
 lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Command_elabCheckFailure___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabInductiveViews(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabAxiom_match__3___rarg(lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Command_elabAxiom___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__21(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Command_namespace___elambda__1___closed__2;
@@ -168,15 +168,14 @@ lean_object* l_Lean_Elab_Command_expandInitCmd___closed__10;
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__33;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Command_elabAttr___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*);
 lean_object* l_Lean_Elab_Command_expandDeclNamespace_x3f_match__1(lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
 lean_object* l_Lean_Syntax_getId(lean_object*);
 lean_object* l_Lean_Elab_Command_elabClassInductive(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Command_elabAttr___spec__3___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_synthesizeSyntheticMVars_loop(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
 extern lean_object* l_Lean_Elab_Command_checkValidCtorModifier___rarg___lambda__3___closed__2;
 extern lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__2;
 extern lean_object* l_Lean_Parser_Command_namespace___elambda__1___closed__1;
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__19;
 lean_object* l_Lean_Elab_Command_expandInitialize___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Macro_throwErrorAt___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -193,6 +192,7 @@ lean_object* l___regBuiltin_Lean_Elab_Command_elabAttr___closed__1;
 uint8_t l_Lean_Elab_Command_isDefLike(lean_object*);
 lean_object* l_Lean_Elab_Command_expandDeclIdNamespace_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_expandDeclNamespace_x3f(lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 extern lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_process_tryToProcess___lambda__1___closed__2;
 lean_object* l_Lean_Elab_Command_elabCommand(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_sortDeclLevelParams(lean_object*, lean_object*, lean_object*);
@@ -211,7 +211,6 @@ uint8_t l___private_Lean_Elab_Declaration_0__Lean_Elab_Command_isMutualDef(lean_
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Command_expandMutualElement___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l___private_Lean_Elab_Declaration_0__Lean_Elab_Command_isMutualPreambleCommand(lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
 lean_object* l___regBuiltin_Lean_Elab_Command_expandBuiltinInitialize(lean_object*);
 lean_object* l_Lean_Elab_Command_expandMutualPreamble(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nullKind___closed__2;
@@ -271,6 +270,7 @@ lean_object* l___private_Lean_Elab_Declaration_0__Lean_Elab_Command_splitMutualP
 lean_object* l_Lean_Elab_expandDeclSig(lean_object*);
 lean_object* l_Lean_Elab_Term_elabType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_Declaration_0__Lean_Elab_Command_inductiveSyntaxToView___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Declaration_0__Lean_Elab_Command_isMutualDef___boxed(lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_Declaration_0__Lean_Elab_Command_inductiveSyntaxToView___spec__3___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -314,7 +314,6 @@ lean_object* l_Lean_Elab_Command_elabAxiom___lambda__2(lean_object*, lean_object
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Command_elabAttr___spec__3(size_t, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_checkValidCtorModifier___at___private_Lean_Elab_Declaration_0__Lean_Elab_Command_inductiveSyntaxToView___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_leanPosToLspPos(lean_object*, lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__3;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabInductive(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -348,6 +347,7 @@ extern lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__1;
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_Declaration_0__Lean_Elab_Command_inductiveSyntaxToView___spec__3___lambda__2___closed__2;
 lean_object* l_Lean_Elab_Command_expandInitCmd___closed__5;
 lean_object* l_Lean_Elab_Command_expandBuiltinInitialize(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
 lean_object* l_Lean_Elab_Command_elabAxiom___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*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_expandMutualNamespace_match__2___rarg(lean_object*, lean_object*, lean_object*);
@@ -7238,7 +7238,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
@@ -7377,9 +7377,9 @@ lean_inc(x_18);
 x_35 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_35, 0, x_18);
 lean_ctor_set(x_35, 1, x_34);
-x_36 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_36 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 x_37 = l_Lean_addMacroScope(x_20, x_36, x_19);
-x_38 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
+x_38 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
 x_39 = l_Lean_Elab_Command_expandInitCmd___closed__12;
 lean_inc(x_18);
 x_40 = lean_alloc_ctor(3, 4, 0);
@@ -7403,7 +7403,7 @@ lean_ctor_set(x_48, 1, x_46);
 x_49 = lean_array_push(x_28, x_35);
 lean_inc(x_49);
 x_50 = lean_array_push(x_49, x_48);
-x_51 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_51 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_52 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_52, 0, x_51);
 lean_ctor_set(x_52, 1, x_50);
@@ -7585,9 +7585,9 @@ lean_inc(x_134);
 x_152 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_152, 0, x_134);
 lean_ctor_set(x_152, 1, x_151);
-x_153 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_153 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 x_154 = l_Lean_addMacroScope(x_137, x_153, x_136);
-x_155 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
+x_155 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
 x_156 = l_Lean_Elab_Command_expandInitCmd___closed__12;
 lean_inc(x_134);
 x_157 = lean_alloc_ctor(3, 4, 0);
@@ -7611,7 +7611,7 @@ lean_ctor_set(x_165, 1, x_163);
 x_166 = lean_array_push(x_145, x_152);
 lean_inc(x_166);
 x_167 = lean_array_push(x_166, x_165);
-x_168 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_168 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_169 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_169, 0, x_168);
 lean_ctor_set(x_169, 1, x_167);
@@ -7847,11 +7847,11 @@ lean_inc(x_254);
 x_303 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_303, 0, x_254);
 lean_ctor_set(x_303, 1, x_302);
-x_304 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_304 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_inc(x_255);
 lean_inc(x_256);
 x_305 = l_Lean_addMacroScope(x_256, x_304, x_255);
-x_306 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
+x_306 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
 x_307 = l_Lean_Elab_Command_expandInitCmd___closed__12;
 lean_inc(x_254);
 x_308 = lean_alloc_ctor(3, 4, 0);
@@ -7859,10 +7859,10 @@ lean_ctor_set(x_308, 0, x_254);
 lean_ctor_set(x_308, 1, x_306);
 lean_ctor_set(x_308, 2, x_305);
 lean_ctor_set(x_308, 3, x_307);
-x_309 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_309 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_310 = l_Lean_addMacroScope(x_256, x_309, x_255);
-x_311 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
-x_312 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
+x_311 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
+x_312 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 lean_inc(x_254);
 x_313 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_313, 0, x_254);
@@ -7881,7 +7881,7 @@ lean_ctor_set(x_319, 0, x_318);
 lean_ctor_set(x_319, 1, x_317);
 x_320 = lean_array_push(x_259, x_303);
 x_321 = lean_array_push(x_320, x_319);
-x_322 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_322 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_323 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_323, 0, x_322);
 lean_ctor_set(x_323, 1, x_321);
@@ -8028,11 +8028,11 @@ lean_inc(x_354);
 x_404 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_404, 0, x_354);
 lean_ctor_set(x_404, 1, x_403);
-x_405 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_405 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_inc(x_356);
 lean_inc(x_357);
 x_406 = l_Lean_addMacroScope(x_357, x_405, x_356);
-x_407 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__11;
+x_407 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__11;
 x_408 = l_Lean_Elab_Command_expandInitCmd___closed__12;
 lean_inc(x_354);
 x_409 = lean_alloc_ctor(3, 4, 0);
@@ -8040,10 +8040,10 @@ lean_ctor_set(x_409, 0, x_354);
 lean_ctor_set(x_409, 1, x_407);
 lean_ctor_set(x_409, 2, x_406);
 lean_ctor_set(x_409, 3, x_408);
-x_410 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_410 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_411 = l_Lean_addMacroScope(x_357, x_410, x_356);
-x_412 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__16;
-x_413 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__19;
+x_412 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__16;
+x_413 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__19;
 lean_inc(x_354);
 x_414 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_414, 0, x_354);
@@ -8062,7 +8062,7 @@ lean_ctor_set(x_420, 0, x_419);
 lean_ctor_set(x_420, 1, x_418);
 x_421 = lean_array_push(x_360, x_404);
 x_422 = lean_array_push(x_421, x_420);
-x_423 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_423 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_424 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_424, 0, x_423);
 lean_ctor_set(x_424, 1, x_422);
diff --git a/stage0/stdlib/Lean/Elab/DefView.c b/stage0/stdlib/Lean/Elab/DefView.c
index cf8b7fe16d..cb4e48f464 100644
--- a/stage0/stdlib/Lean/Elab/DefView.c
+++ b/stage0/stdlib/Lean/Elab/DefView.c
@@ -41,7 +41,6 @@ lean_object* l_Lean_Elab_Command_mkDefViewOfInstance___lambda__1(lean_object*, l
 extern lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandOptIdent___closed__1;
 lean_object* l_Lean_Elab_Command_mkDefViewOfConstant___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__2;
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__2;
 lean_object* l_Lean_Elab_liftMacroM___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__23;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_mkDefViewOfInstance___spec__3___boxed(lean_object*, lean_object*);
@@ -62,7 +61,6 @@ extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_287____c
 lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements;
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__1;
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__16;
 lean_object* l_Lean_Elab_Command_mkDefViewOfAbbrev___closed__1;
 lean_object* l_Lean_Elab_Command_MkInstanceName_collect___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_DefKind_isExample_match__1(lean_object*);
@@ -91,6 +89,7 @@ lean_object* l_Lean_Elab_Command_mkDefViewOfConstant___closed__3;
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
 lean_object* l_Lean_Elab_mkFreshInstanceName(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_mkDefViewOfConstant_match__1___rarg(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__15;
 extern lean_object* l_Array_forInUnsafe_loop___at___private_Init_NotationExtra_0__Lean_mkHintBody___spec__1___closed__2;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_MkInstanceName_main___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_mkDefViewOfConstant___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -212,6 +211,7 @@ lean_object* l_Lean_Elab_Command_mkDefView(lean_object*, lean_object*, lean_obje
 lean_object* l_Lean_Elab_Command_mkDefView___closed__1;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 uint8_t l_List_isEmpty___rarg(lean_object*);
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__1;
 lean_object* l_Lean_Elab_Command_getScope___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__5;
 lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__3;
@@ -3272,8 +3272,8 @@ static lean_object* _init_l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkI
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/BEq.c b/stage0/stdlib/Lean/Elab/Deriving/BEq.c
index 2216932ee1..1c39ff9bbc 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/BEq.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/BEq.c
@@ -87,7 +87,6 @@ lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Subarray___hyg_903____closed__4;
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
 lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkAlts_match__1(lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Deriving_BEq_mkMatch(lean_object*);
 lean_object* l_Lean_Elab_Deriving_BEq_mkAuxFunction___lambda__1___closed__1;
 lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkAlts_match__1___rarg(lean_object*, lean_object*);
@@ -109,6 +108,7 @@ extern lean_object* l_Lean_instInhabitedExpr;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__1;
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_throwError___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__2;
@@ -2815,7 +2815,7 @@ lean_ctor_set(x_58, 2, x_55);
 lean_ctor_set(x_58, 3, x_57);
 x_59 = lean_array_push(x_44, x_53);
 x_60 = lean_array_push(x_59, x_58);
-x_61 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_61 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_62 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_62, 0, x_61);
 lean_ctor_set(x_62, 1, x_60);
@@ -2928,7 +2928,7 @@ lean_ctor_set(x_124, 2, x_121);
 lean_ctor_set(x_124, 3, x_123);
 x_125 = lean_array_push(x_110, x_119);
 x_126 = lean_array_push(x_125, x_124);
-x_127 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_127 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_128 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_128, 0, x_127);
 lean_ctor_set(x_128, 1, x_126);
@@ -3072,7 +3072,7 @@ lean_ctor_set(x_206, 2, x_203);
 lean_ctor_set(x_206, 3, x_205);
 x_207 = lean_array_push(x_192, x_201);
 x_208 = lean_array_push(x_207, x_206);
-x_209 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_209 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_210 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_210, 0, x_209);
 lean_ctor_set(x_210, 1, x_208);
@@ -3199,7 +3199,7 @@ lean_ctor_set(x_279, 2, x_276);
 lean_ctor_set(x_279, 3, x_278);
 x_280 = lean_array_push(x_265, x_274);
 x_281 = lean_array_push(x_280, x_279);
-x_282 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_282 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_283 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_283, 0, x_282);
 lean_ctor_set(x_283, 1, x_281);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/DecEq.c b/stage0/stdlib/Lean/Elab/Deriving/DecEq.c
index 5fbb29a80b..3885bea7e3 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/DecEq.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/DecEq.c
@@ -110,7 +110,6 @@ extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Subarray___hyg_903___
 lean_object* l_Lean_throwError___at_Lean_Elab_Deriving_DecEq_mkMatch_mkAlts___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
 extern lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__43;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Deriving_DecEq_mkMatch_mkSameCtorRhs___closed__8;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_DecEq_mkMatch_mkAlts___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_DecEq_mkDecEqCmds(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -143,6 +142,7 @@ extern lean_object* l_Array_forInUnsafe_loop___at___private_Init_NotationExtra_0
 extern lean_object* l_Lean_Elab_Tactic_evalIntro___closed__2;
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
 lean_object* l_Lean_Elab_Deriving_DecEq_mkMatch_mkAlts_match__1___rarg(lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14569____closed__12;
 lean_object* l_Lean_Core_transform___at_Lean_Core_betaReduce___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -5316,7 +5316,7 @@ lean_ctor_set(x_107, 0, x_75);
 lean_ctor_set(x_107, 1, x_106);
 x_108 = lean_array_push(x_54, x_107);
 x_109 = lean_array_push(x_108, x_73);
-x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_111 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_111, 0, x_110);
 lean_ctor_set(x_111, 1, x_109);
@@ -5413,7 +5413,7 @@ lean_ctor_set(x_162, 0, x_75);
 lean_ctor_set(x_162, 1, x_161);
 x_163 = lean_array_push(x_54, x_162);
 x_164 = lean_array_push(x_163, x_73);
-x_165 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_165 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_166 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_166, 0, x_165);
 lean_ctor_set(x_166, 1, x_164);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/FromToJson.c b/stage0/stdlib/Lean/Elab/Deriving/FromToJson.c
index afef57848a..f787390f85 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/FromToJson.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/FromToJson.c
@@ -95,7 +95,6 @@ extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_1585
 lean_object* l_Lean_getStructureFieldsFlattened(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Name_toString(lean_object*, uint8_t);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_match__1___rarg(lean_object*, lean_object*);
 extern lean_object* l___private_Init_Meta_0__Lean_quoteOption___rarg___closed__2;
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__1___closed__7;
@@ -112,6 +111,7 @@ extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____close
 extern lean_object* l_Lean_Parser_Term_doLetArrow___elambda__1___closed__1;
 lean_object* l_Lean_Syntax_mkStrLit(lean_object*, lean_object*);
 uint8_t l_Lean_Elab_Deriving_FromToJson_mkJsonField___lambda__1(uint32_t);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14569____closed__12;
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__1___closed__14;
 lean_object* l_Lean_Elab_Deriving_mkHeader___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -2829,7 +2829,7 @@ x_118 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_118, 0, x_117);
 lean_ctor_set(x_118, 1, x_116);
 x_119 = lean_array_push(x_93, x_118);
-x_120 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_120 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_121 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_121, 0, x_120);
 lean_ctor_set(x_121, 1, x_119);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/Hashable.c b/stage0/stdlib/Lean/Elab/Deriving/Hashable.c
index d6e2c076f1..96ee50be02 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/Hashable.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/Hashable.c
@@ -79,7 +79,6 @@ extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__13;
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Subarray___hyg_903____closed__4;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts_match__2(lean_object*);
 lean_object* l_Lean_Elab_Deriving_Hashable_mkMatch___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__6;
@@ -97,6 +96,7 @@ lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_Deriving_Hashable_mkHashableH
 extern lean_object* l_Lean_instInhabitedExpr;
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkHashFuncs___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__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*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts_match__1(lean_object*);
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
@@ -2091,7 +2091,7 @@ lean_ctor_set(x_67, 2, x_64);
 lean_ctor_set(x_67, 3, x_66);
 x_68 = lean_array_push(x_53, x_62);
 x_69 = lean_array_push(x_68, x_67);
-x_70 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_70 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_71 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_71, 0, x_70);
 lean_ctor_set(x_71, 1, x_69);
@@ -2205,7 +2205,7 @@ lean_ctor_set(x_133, 2, x_130);
 lean_ctor_set(x_133, 3, x_132);
 x_134 = lean_array_push(x_119, x_128);
 x_135 = lean_array_push(x_134, x_133);
-x_136 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_136 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_137 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_137, 0, x_136);
 lean_ctor_set(x_137, 1, x_135);
@@ -2363,7 +2363,7 @@ lean_ctor_set(x_217, 2, x_214);
 lean_ctor_set(x_217, 3, x_216);
 x_218 = lean_array_push(x_203, x_212);
 x_219 = lean_array_push(x_218, x_217);
-x_220 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_220 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_221 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_221, 0, x_220);
 lean_ctor_set(x_221, 1, x_219);
@@ -2491,7 +2491,7 @@ lean_ctor_set(x_290, 2, x_287);
 lean_ctor_set(x_290, 3, x_289);
 x_291 = lean_array_push(x_276, x_285);
 x_292 = lean_array_push(x_291, x_290);
-x_293 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_293 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_294 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_294, 0, x_293);
 lean_ctor_set(x_294, 1, x_292);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/Inhabited.c b/stage0/stdlib/Lean/Elab/Deriving/Inhabited.c
index b9f4b6319d..2ec7afdb97 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/Inhabited.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/Inhabited.c
@@ -107,7 +107,6 @@ lean_object* l___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedIn
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Subarray___hyg_903____closed__4;
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedInstanceUsing_mkInstanceCmdWith___spec__8___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*);
 extern lean_object* l_myMacro____x40_Init_NotationExtra___hyg_4440____closed__6;
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedInstanceUsing_mkInstanceCmdWith___spec__8___closed__2;
@@ -141,6 +140,7 @@ lean_object* l___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedIn
 lean_object* l___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedInstance___closed__3;
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
 extern lean_object* l_myMacro____x40_Init_NotationExtra___hyg_4848____lambda__3___closed__9;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_throwError___at___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedInstanceUsing_mkInstanceCmdWith___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedInstanceUsing_addLocalInstancesForParamsAux___rarg___closed__2;
 lean_object* l___private_Lean_Elab_Deriving_Inhabited_0__Lean_Elab_mkInhabitedInstanceUsing_collectUsedLocalsInsts_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -5514,7 +5514,7 @@ lean_ctor_set(x_132, 0, x_120);
 lean_ctor_set(x_132, 1, x_131);
 x_133 = lean_array_push(x_50, x_132);
 x_134 = lean_array_push(x_133, x_79);
-x_135 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_135 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_136 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_136, 0, x_135);
 lean_ctor_set(x_136, 1, x_134);
@@ -5577,7 +5577,7 @@ lean_ctor_set(x_166, 0, x_120);
 lean_ctor_set(x_166, 1, x_165);
 x_167 = lean_array_push(x_50, x_166);
 x_168 = lean_array_push(x_167, x_79);
-x_169 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_169 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_170 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_170, 0, x_169);
 lean_ctor_set(x_170, 1, x_168);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/Ord.c b/stage0/stdlib/Lean/Elab/Deriving/Ord.c
index c46ce34bbd..ef39d75d76 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/Ord.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/Ord.c
@@ -89,7 +89,6 @@ extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Subarray___hyg_903___
 lean_object* l_Lean_Elab_Deriving_Ord_mkOrdInstanceHandler(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_Ord_mkMatch_mkAlts_match__1(lean_object*);
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__5;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__11;
 extern lean_object* l_Lean_Core_betaReduce___closed__2;
@@ -110,6 +109,7 @@ extern lean_object* l_myMacro____x40_Init_Notation___hyg_6685____closed__6;
 extern lean_object* l_Lean_instInhabitedExpr;
 lean_object* l_Array_reverse___rarg(lean_object*);
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Core_transform___at_Lean_Core_betaReduce___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3120,7 +3120,7 @@ lean_ctor_set(x_216, 2, x_213);
 lean_ctor_set(x_216, 3, x_215);
 x_217 = lean_array_push(x_202, x_211);
 x_218 = lean_array_push(x_217, x_216);
-x_219 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_219 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_220 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_220, 0, x_219);
 lean_ctor_set(x_220, 1, x_218);
@@ -3233,7 +3233,7 @@ lean_ctor_set(x_282, 2, x_279);
 lean_ctor_set(x_282, 3, x_281);
 x_283 = lean_array_push(x_268, x_277);
 x_284 = lean_array_push(x_283, x_282);
-x_285 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_285 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_286 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_286, 0, x_285);
 lean_ctor_set(x_286, 1, x_284);
@@ -3392,7 +3392,7 @@ lean_ctor_set(x_66, 2, x_63);
 lean_ctor_set(x_66, 3, x_65);
 x_67 = lean_array_push(x_52, x_61);
 x_68 = lean_array_push(x_67, x_66);
-x_69 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_69 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_70 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_70, 0, x_69);
 lean_ctor_set(x_70, 1, x_68);
@@ -3519,7 +3519,7 @@ lean_ctor_set(x_139, 2, x_136);
 lean_ctor_set(x_139, 3, x_138);
 x_140 = lean_array_push(x_125, x_134);
 x_141 = lean_array_push(x_140, x_139);
-x_142 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_142 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_143 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_143, 0, x_142);
 lean_ctor_set(x_143, 1, x_141);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/Repr.c b/stage0/stdlib/Lean/Elab/Deriving/Repr.c
index 834956e5f2..80bc0d77ce 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/Repr.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/Repr.c
@@ -126,7 +126,6 @@ lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct___rarg___lambda__1(lean_o
 extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Subarray___hyg_903____closed__4;
 lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct_match__1___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__43;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__27;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__11;
 extern lean_object* l_Lean_strLitKind___closed__2;
@@ -156,6 +155,7 @@ lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAl
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__23;
 lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct___rarg___lambda__2___closed__4;
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__2;
 lean_object* l_Lean_mkSepArray(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isProof(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -4713,7 +4713,7 @@ lean_ctor_set(x_58, 2, x_55);
 lean_ctor_set(x_58, 3, x_57);
 x_59 = lean_array_push(x_44, x_53);
 x_60 = lean_array_push(x_59, x_58);
-x_61 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_61 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_62 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_62, 0, x_61);
 lean_ctor_set(x_62, 1, x_60);
@@ -4826,7 +4826,7 @@ lean_ctor_set(x_124, 2, x_121);
 lean_ctor_set(x_124, 3, x_123);
 x_125 = lean_array_push(x_110, x_119);
 x_126 = lean_array_push(x_125, x_124);
-x_127 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_127 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_128 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_128, 0, x_127);
 lean_ctor_set(x_128, 1, x_126);
@@ -4970,7 +4970,7 @@ lean_ctor_set(x_206, 2, x_203);
 lean_ctor_set(x_206, 3, x_205);
 x_207 = lean_array_push(x_192, x_201);
 x_208 = lean_array_push(x_207, x_206);
-x_209 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_209 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_210 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_210, 0, x_209);
 lean_ctor_set(x_210, 1, x_208);
@@ -5097,7 +5097,7 @@ lean_ctor_set(x_279, 2, x_276);
 lean_ctor_set(x_279, 3, x_278);
 x_280 = lean_array_push(x_265, x_274);
 x_281 = lean_array_push(x_280, x_279);
-x_282 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_282 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_283 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_283, 0, x_282);
 lean_ctor_set(x_283, 1, x_281);
diff --git a/stage0/stdlib/Lean/Elab/Deriving/Util.c b/stage0/stdlib/Lean/Elab/Deriving/Util.c
index bbda7ac83e..5967ea2c45 100644
--- a/stage0/stdlib/Lean/Elab/Deriving/Util.c
+++ b/stage0/stdlib/Lean/Elab/Deriving/Util.c
@@ -103,7 +103,6 @@ lean_object* l_Lean_Elab_Deriving_mkLet(lean_object*, lean_object*, lean_object*
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_mkContext___spec__4(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_fvarId_x21(lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_mkDiscrs___spec__2(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_mkInstImplicitBinders___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Elab_Deriving_mkInstImplicitBinders___spec__2(lean_object*);
@@ -126,6 +125,7 @@ lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_mkInstanceCmds___spe
 lean_object* l_Lean_Parser_Term_explicitBinder(uint8_t);
 extern lean_object* l_myMacro____x40_Init_NotationExtra___hyg_4848____lambda__3___closed__9;
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__6;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Deriving_mkInductiveApp___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14569____closed__12;
 lean_object* l_Lean_Elab_Deriving_mkHeader___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -135,6 +135,7 @@ extern lean_object* l_myMacro____x40_Init_Notation___hyg_71____closed__2;
 extern lean_object* l_Lean_KernelException_toMessageData___closed__3;
 lean_object* l_Lean_Elab_Deriving_mkInductArgNames___closed__1;
 size_t lean_usize_of_nat(lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_object* l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_mkImplicitBinders___boxed__const__1;
 extern lean_object* l_Lean_Parser_Tactic_inductionAlt___closed__5;
@@ -151,7 +152,6 @@ lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_mkLocalInstanceLetDe
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_mkHeader___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___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_mkDiscrs___spec__2___boxed(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_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
 lean_object* l_Lean_Meta_getLocalDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_mkInductiveApp___spec__1(size_t, size_t, lean_object*);
@@ -2047,7 +2047,7 @@ lean_ctor_set(x_95, 0, x_85);
 lean_ctor_set(x_95, 1, x_94);
 x_96 = lean_array_push(x_55, x_95);
 x_97 = lean_array_push(x_96, x_59);
-x_98 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_98 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_99 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_99, 0, x_98);
 lean_ctor_set(x_99, 1, x_97);
@@ -2480,7 +2480,7 @@ x_50 = l_Array_append___rarg(x_3, x_6);
 x_51 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_51, 0, x_2);
 lean_ctor_set(x_51, 1, x_50);
-x_52 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_52 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_53 = lean_name_mk_string(x_4, x_52);
 x_54 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_inc(x_19);
@@ -2591,7 +2591,7 @@ x_108 = l_Array_append___rarg(x_3, x_6);
 x_109 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_109, 0, x_2);
 lean_ctor_set(x_109, 1, x_108);
-x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_110 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_111 = lean_name_mk_string(x_4, x_110);
 x_112 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_inc(x_19);
diff --git a/stage0/stdlib/Lean/Elab/Do.c b/stage0/stdlib/Lean/Elab/Do.c
index 569fb2380f..46cdf2afd7 100644
--- a/stage0/stdlib/Lean/Elab/Do.c
+++ b/stage0/stdlib/Lean/Elab/Do.c
@@ -518,7 +518,6 @@ extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__8;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_checkLetArrowRHS___closed__3;
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Term_Do_ToCodeBlock_doTryToCode___spec__7___closed__6;
 extern lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__43;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_concatWith_match__1(lean_object*);
 lean_object* l_Lean_Elab_Term_Do_getDoIdDeclVar(lean_object*);
 lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_destructTuple_destruct___closed__3;
@@ -663,6 +662,7 @@ lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_destructTuple_destruc
 lean_object* l_Lean_Elab_Term_Do_mkSingletonDoSeq(lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_continueToTerm___closed__30;
 extern lean_object* l_Lean_instInhabitedSyntax;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_Do_ToCodeBlock_doSeqToCode___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__7;
 lean_object* l_Lean_Elab_Term_Do_mkReassignCore___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1083,8 +1083,8 @@ lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult___closed__8;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doReassignArrowToCode___closed__6;
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_ToCodeBlock_expandLiftMethodAux___spec__4(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2(lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_insertVars___boxed(lean_object*, lean_object*);
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2(lean_object*, size_t, size_t, lean_object*);
 lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_expandDoIf_x3f___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_breakToTerm___closed__20;
 lean_object* l_Lean_mkIdentFromRef___at_Lean_Elab_Term_Do_ToTerm_mkUVarTuple___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -8096,7 +8096,7 @@ size_t x_7; size_t x_8; lean_object* x_9;
 x_7 = 0;
 x_8 = lean_usize_of_nat(x_3);
 lean_dec(x_3);
-x_9 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2(x_2, x_7, x_8, x_1);
+x_9 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2(x_2, x_7, x_8, x_1);
 return x_9;
 }
 }
@@ -38737,7 +38737,7 @@ lean_ctor_set(x_68, 0, x_67);
 lean_ctor_set(x_68, 1, x_66);
 x_69 = lean_array_push(x_64, x_54);
 x_70 = lean_array_push(x_69, x_68);
-x_71 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_71 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_72 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_72, 0, x_71);
 lean_ctor_set(x_72, 1, x_70);
@@ -38848,7 +38848,7 @@ lean_ctor_set(x_129, 0, x_128);
 lean_ctor_set(x_129, 1, x_127);
 x_130 = lean_array_push(x_125, x_115);
 x_131 = lean_array_push(x_130, x_129);
-x_132 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_132 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_133 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_133, 0, x_132);
 lean_ctor_set(x_133, 1, x_131);
@@ -39077,7 +39077,7 @@ lean_ctor_set(x_220, 0, x_219);
 lean_ctor_set(x_220, 1, x_218);
 x_221 = lean_array_push(x_216, x_206);
 x_222 = lean_array_push(x_221, x_220);
-x_223 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_223 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_224 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_224, 0, x_223);
 lean_ctor_set(x_224, 1, x_222);
@@ -39343,7 +39343,7 @@ lean_ctor_set(x_319, 0, x_318);
 lean_ctor_set(x_319, 1, x_317);
 x_320 = lean_array_push(x_315, x_305);
 x_321 = lean_array_push(x_320, x_319);
-x_322 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_322 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_323 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_323, 0, x_322);
 lean_ctor_set(x_323, 1, x_321);
diff --git a/stage0/stdlib/Lean/Elab/Import.c b/stage0/stdlib/Lean/Elab/Import.c
index 405caa9cf6..97ead10a52 100644
--- a/stage0/stdlib/Lean/Elab/Import.c
+++ b/stage0/stdlib/Lean/Elab/Import.c
@@ -13,6 +13,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* lean_string_push(lean_object*, uint32_t);
 lean_object* l_Lean_Elab_headerToImports___closed__4;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parseHeader(lean_object*, lean_object*);
@@ -31,8 +32,11 @@ lean_object* l_Lean_Elab_parseImports___closed__1;
 lean_object* l_Lean_Elab_parseImports_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_headerToImports___closed__3;
 lean_object* l_Lean_Elab_printImports_match__1(lean_object*);
+lean_object* l_IO_print___at_IO_println___spec__1(lean_object*, lean_object*);
+lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getId(lean_object*);
 lean_object* l_Lean_Elab_processHeader___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_to_list(lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_ofString(lean_object*);
@@ -45,11 +49,9 @@ uint8_t l_Lean_Syntax_isNone(lean_object*);
 lean_object* l_List_map___at_Lean_Elab_headerToImports___spec__1(lean_object*);
 lean_object* l_Lean_Elab_parseImports(lean_object*, lean_object*, lean_object*);
 lean_object* lean_print_imports(lean_object*, lean_object*, lean_object*);
-lean_object* l_IO_println___at_Lean_instEval___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_printImports_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
-lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_println___at_Lean_Elab_printImports___spec__1(lean_object*, lean_object*);
 lean_object* l_List_map___at_Lean_Elab_headerToImports___spec__1(lean_object* x_1) {
 _start:
 {
@@ -902,7 +904,17 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Elab_printImports_match__1___rarg), 2, 0
 return x_2;
 }
 }
-lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_IO_println___at_Lean_Elab_printImports___spec__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint32_t x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = 10;
+x_4 = lean_string_push(x_1, x_3);
+x_5 = l_IO_print___at_IO_println___spec__1(x_4, x_2);
+return x_5;
+}
+}
+lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -929,7 +941,7 @@ lean_inc(x_9);
 x_10 = lean_ctor_get(x_8, 1);
 lean_inc(x_10);
 lean_dec(x_8);
-x_11 = l_IO_println___at_Lean_instEval___spec__1(x_9, x_10);
+x_11 = l_IO_println___at_Lean_Elab_printImports___spec__1(x_9, x_10);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_object* x_12; lean_object* x_13; 
@@ -1007,7 +1019,7 @@ x_7 = lean_ctor_get(x_5, 0);
 lean_inc(x_7);
 lean_dec(x_5);
 x_8 = lean_box(0);
-x_9 = l_List_forIn_loop___at_Lean_Elab_printImports___spec__1(x_7, x_8, x_6);
+x_9 = l_List_forIn_loop___at_Lean_Elab_printImports___spec__2(x_7, x_8, x_6);
 lean_dec(x_7);
 if (lean_obj_tag(x_9) == 0)
 {
@@ -1080,11 +1092,11 @@ return x_21;
 }
 }
 }
-lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_List_forIn_loop___at_Lean_Elab_printImports___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_List_forIn_loop___at_Lean_Elab_printImports___spec__1(x_1, x_2, x_3);
+x_4 = l_List_forIn_loop___at_Lean_Elab_printImports___spec__2(x_1, x_2, x_3);
 lean_dec(x_1);
 return x_4;
 }
diff --git a/stage0/stdlib/Lean/Elab/Log.c b/stage0/stdlib/Lean/Elab/Log.c
index 86ac8c08b9..6e291a88e7 100644
--- a/stage0/stdlib/Lean/Elab/Log.c
+++ b/stage0/stdlib/Lean/Elab/Log.c
@@ -43,6 +43,7 @@ lean_object* l_Lean_Elab_instMonadLog___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_logDbgTrace___rarg___closed__1;
 lean_object* l_Lean_Elab_instMonadLog___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getRefPosition___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3;
 extern lean_object* l___private_Lean_Util_Trace_0__Lean_addNode___rarg___lambda__1___closed__3;
 lean_object* l_Lean_Elab_logAt___rarg___lambda__5(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_trace___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -84,7 +85,6 @@ lean_object* l_Lean_Elab_trace___rarg(lean_object*, lean_object*, lean_object*,
 lean_object* l_Lean_Elab_logAt___rarg___lambda__9(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_logAt___rarg___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Util_Trace_0__Lean_addNode___rarg___lambda__1___closed__1;
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3;
 lean_object* l_Lean_Elab_logAt___rarg___lambda__7(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_logException_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getRefPos(lean_object*);
@@ -1270,7 +1270,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Elab_initFn____x40_Lean_Elab_Util___hyg_1242____closed__1;
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
diff --git a/stage0/stdlib/Lean/Elab/Match.c b/stage0/stdlib/Lean/Elab/Match.c
index 8845686ce3..2f6044c9b6 100644
--- a/stage0/stdlib/Lean/Elab/Match.c
+++ b/stage0/stdlib/Lean/Elab/Match.c
@@ -448,7 +448,6 @@ lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_expandNonAtomicDiscrs
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__8;
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Term_withDepElimPatterns___spec__2(lean_object*, size_t, size_t, lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkUserNameFor_match__1(lean_object*);
 lean_object* l_Lean_throwErrorAt___at_Lean_Elab_Term_getPatternsVars___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -473,6 +472,7 @@ lean_object* l_Lean_Elab_Term_precheckMatch(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_Elab_Term_precheckMatch_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_findDiscrRefinementPath_checkCompatibleApps(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_loop_match__2(lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 lean_object* l_Lean_Expr_isFVar___boxed(lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_getDiscrs___boxed(lean_object*);
 lean_object* l_Lean_Elab_Term_precheckMatch_match__5___rarg(lean_object*, lean_object*, lean_object*);
@@ -508,7 +508,6 @@ lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_add
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg___closed__1;
 extern lean_object* l_Lean_choiceKind;
 lean_object* l_Std_RBNode_revFold___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_collectDeps___spec__3___boxed(lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
 extern lean_object* l_Lean_charLitKind;
 lean_object* l_Lean_Elab_Term_withDepElimPatterns_match__1___rarg(lean_object*, lean_object*);
 uint8_t l_Array_contains___at_Lean_findField_x3f___spec__1(lean_object*, lean_object*);
@@ -584,6 +583,7 @@ lean_object* l_Lean_LocalDecl_toExpr(lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_CollectPatternVars_collect___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*);
 extern lean_object* l_Lean_instInhabitedSyntax;
 lean_object* l_Lean_Meta_Match_instantiateAltLHSMVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_generalize___lambda__2___boxed__const__1;
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_expandNonAtomicDiscrs_x3f_loop___closed__2;
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -2159,92 +2159,94 @@ return x_80;
 }
 else
 {
-uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
 x_81 = lean_ctor_get_uint8(x_27, 4);
 x_82 = lean_ctor_get_uint8(x_27, 5);
 x_83 = lean_ctor_get_uint8(x_27, 6);
 x_84 = lean_ctor_get_uint8(x_27, 7);
 x_85 = lean_ctor_get_uint8(x_27, 8);
+x_86 = lean_ctor_get_uint8(x_27, 9);
 lean_dec(x_27);
-x_86 = 1;
-x_87 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_87, 0, x_86);
-lean_ctor_set_uint8(x_87, 1, x_86);
-lean_ctor_set_uint8(x_87, 2, x_86);
-lean_ctor_set_uint8(x_87, 3, x_86);
-lean_ctor_set_uint8(x_87, 4, x_81);
-lean_ctor_set_uint8(x_87, 5, x_82);
-lean_ctor_set_uint8(x_87, 6, x_83);
-lean_ctor_set_uint8(x_87, 7, x_84);
-lean_ctor_set_uint8(x_87, 8, x_85);
-x_88 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_88, 0, x_87);
-lean_ctor_set(x_88, 1, x_28);
-lean_ctor_set(x_88, 2, x_29);
-lean_ctor_set(x_88, 3, x_30);
+x_87 = 1;
+x_88 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_88, 0, x_87);
+lean_ctor_set_uint8(x_88, 1, x_87);
+lean_ctor_set_uint8(x_88, 2, x_87);
+lean_ctor_set_uint8(x_88, 3, x_87);
+lean_ctor_set_uint8(x_88, 4, x_81);
+lean_ctor_set_uint8(x_88, 5, x_82);
+lean_ctor_set_uint8(x_88, 6, x_83);
+lean_ctor_set_uint8(x_88, 7, x_84);
+lean_ctor_set_uint8(x_88, 8, x_85);
+lean_ctor_set_uint8(x_88, 9, x_86);
+x_89 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_89, 0, x_88);
+lean_ctor_set(x_89, 1, x_28);
+lean_ctor_set(x_89, 2, x_29);
+lean_ctor_set(x_89, 3, x_30);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_4);
 lean_inc(x_3);
-x_89 = l_Lean_Elab_Term_elabTermEnsuringType(x_24, x_25, x_86, x_86, x_26, x_3, x_4, x_88, x_7, x_8, x_9, x_21);
-if (lean_obj_tag(x_89) == 0)
+x_90 = l_Lean_Elab_Term_elabTermEnsuringType(x_24, x_25, x_87, x_87, x_26, x_3, x_4, x_89, x_7, x_8, x_9, x_21);
+if (lean_obj_tag(x_90) == 0)
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_100; lean_object* x_101; lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; 
-x_90 = lean_ctor_get(x_89, 0);
-lean_inc(x_90);
-x_91 = lean_ctor_get(x_89, 1);
+lean_object* x_91; lean_object* x_92; lean_object* x_93; uint8_t x_101; lean_object* x_102; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; 
+x_91 = lean_ctor_get(x_90, 0);
 lean_inc(x_91);
-lean_dec(x_89);
-x_120 = lean_st_ref_get(x_9, x_91);
-x_121 = lean_ctor_get(x_120, 0);
-lean_inc(x_121);
-x_122 = lean_ctor_get(x_121, 3);
+x_92 = lean_ctor_get(x_90, 1);
+lean_inc(x_92);
+lean_dec(x_90);
+x_121 = lean_st_ref_get(x_9, x_92);
+x_122 = lean_ctor_get(x_121, 0);
 lean_inc(x_122);
-lean_dec(x_121);
-x_123 = lean_ctor_get_uint8(x_122, sizeof(void*)*1);
+x_123 = lean_ctor_get(x_122, 3);
+lean_inc(x_123);
 lean_dec(x_122);
-if (x_123 == 0)
+x_124 = lean_ctor_get_uint8(x_123, sizeof(void*)*1);
+lean_dec(x_123);
+if (x_124 == 0)
 {
-lean_object* x_124; uint8_t x_125; 
-x_124 = lean_ctor_get(x_120, 1);
-lean_inc(x_124);
-lean_dec(x_120);
-x_125 = 0;
-x_100 = x_125;
-x_101 = x_124;
-goto block_119;
+lean_object* x_125; uint8_t x_126; 
+x_125 = lean_ctor_get(x_121, 1);
+lean_inc(x_125);
+lean_dec(x_121);
+x_126 = 0;
+x_101 = x_126;
+x_102 = x_125;
+goto block_120;
 }
 else
 {
-lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; 
-x_126 = lean_ctor_get(x_120, 1);
-lean_inc(x_126);
-lean_dec(x_120);
-x_127 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__5;
-x_128 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_127, x_3, x_4, x_6, x_7, x_8, x_9, x_126);
-x_129 = lean_ctor_get(x_128, 0);
-lean_inc(x_129);
-x_130 = lean_ctor_get(x_128, 1);
+lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; uint8_t x_132; 
+x_127 = lean_ctor_get(x_121, 1);
+lean_inc(x_127);
+lean_dec(x_121);
+x_128 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__5;
+x_129 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_128, x_3, x_4, x_6, x_7, x_8, x_9, x_127);
+x_130 = lean_ctor_get(x_129, 0);
 lean_inc(x_130);
-lean_dec(x_128);
-x_131 = lean_unbox(x_129);
+x_131 = lean_ctor_get(x_129, 1);
+lean_inc(x_131);
 lean_dec(x_129);
-x_100 = x_131;
-x_101 = x_130;
-goto block_119;
+x_132 = lean_unbox(x_130);
+lean_dec(x_130);
+x_101 = x_132;
+x_102 = x_131;
+goto block_120;
 }
-block_99:
+block_100:
 {
-uint8_t x_93; 
-x_93 = l_Lean_Expr_hasLooseBVars(x_23);
-if (x_93 == 0)
+uint8_t x_94; 
+x_94 = l_Lean_Expr_hasLooseBVars(x_23);
+if (x_94 == 0)
 {
-lean_object* x_94; uint8_t x_95; lean_object* x_96; 
-x_94 = lean_box(0);
-x_95 = lean_unbox(x_16);
+lean_object* x_95; uint8_t x_96; lean_object* x_97; 
+x_95 = lean_box(0);
+x_96 = lean_unbox(x_16);
 lean_dec(x_16);
-x_96 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__1(x_23, x_90, x_18, x_20, x_15, x_95, x_94, x_3, x_4, x_6, x_7, x_8, x_9, x_92);
+x_97 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__1(x_23, x_91, x_18, x_20, x_15, x_96, x_95, x_3, x_4, x_6, x_7, x_8, x_9, x_93);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
@@ -2253,14 +2255,14 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_20);
 lean_dec(x_23);
-return x_96;
+return x_97;
 }
 else
 {
-lean_object* x_97; lean_object* x_98; 
+lean_object* x_98; lean_object* x_99; 
 lean_dec(x_16);
-x_97 = lean_box(0);
-x_98 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__1(x_23, x_90, x_18, x_20, x_15, x_86, x_97, x_3, x_4, x_6, x_7, x_8, x_9, x_92);
+x_98 = lean_box(0);
+x_99 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__1(x_23, x_91, x_18, x_20, x_15, x_87, x_98, x_3, x_4, x_6, x_7, x_8, x_9, x_93);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
@@ -2269,64 +2271,64 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_20);
 lean_dec(x_23);
-return x_98;
+return x_99;
 }
 }
-block_119:
+block_120:
 {
-if (x_100 == 0)
+if (x_101 == 0)
 {
 lean_dec(x_22);
-x_92 = x_101;
-goto block_99;
+x_93 = x_102;
+goto block_100;
 }
 else
 {
-lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; 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_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; 
 lean_inc(x_18);
-x_102 = l_Std_fmt___at_Lean_Position_instToFormatPosition___spec__1(x_18);
-x_103 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_103, 0, x_102);
-x_104 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__7;
-x_105 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_105, 0, x_104);
-lean_ctor_set(x_105, 1, x_103);
-x_106 = l_Lean_Meta_substCore___lambda__1___closed__3;
-x_107 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_107, 0, x_105);
-lean_ctor_set(x_107, 1, x_106);
-lean_inc(x_90);
-x_108 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_108, 0, x_90);
-x_109 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_109, 0, x_107);
-lean_ctor_set(x_109, 1, x_108);
-x_110 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
-x_111 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_111, 0, x_109);
-lean_ctor_set(x_111, 1, x_110);
-x_112 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_112, 0, x_22);
-x_113 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_113, 0, x_111);
-lean_ctor_set(x_113, 1, x_112);
-x_114 = l_Lean_KernelException_toMessageData___closed__15;
-x_115 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_115, 0, x_113);
-lean_ctor_set(x_115, 1, x_114);
-x_116 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__5;
-x_117 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_116, x_115, x_3, x_4, x_6, x_7, x_8, x_9, x_101);
-x_118 = lean_ctor_get(x_117, 1);
-lean_inc(x_118);
-lean_dec(x_117);
-x_92 = x_118;
-goto block_99;
+x_103 = l_Std_fmt___at_Lean_Position_instToFormatPosition___spec__1(x_18);
+x_104 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_104, 0, x_103);
+x_105 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__7;
+x_106 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_106, 0, x_105);
+lean_ctor_set(x_106, 1, x_104);
+x_107 = l_Lean_Meta_substCore___lambda__1___closed__3;
+x_108 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_108, 0, x_106);
+lean_ctor_set(x_108, 1, x_107);
+lean_inc(x_91);
+x_109 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_109, 0, x_91);
+x_110 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_110, 0, x_108);
+lean_ctor_set(x_110, 1, x_109);
+x_111 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
+x_112 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_112, 0, x_110);
+lean_ctor_set(x_112, 1, x_111);
+x_113 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_113, 0, x_22);
+x_114 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_114, 0, x_112);
+lean_ctor_set(x_114, 1, x_113);
+x_115 = l_Lean_KernelException_toMessageData___closed__15;
+x_116 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_116, 0, x_114);
+lean_ctor_set(x_116, 1, x_115);
+x_117 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__5;
+x_118 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_117, x_116, x_3, x_4, x_6, x_7, x_8, x_9, x_102);
+x_119 = lean_ctor_get(x_118, 1);
+lean_inc(x_119);
+lean_dec(x_118);
+x_93 = x_119;
+goto block_100;
 }
 }
 }
 else
 {
-lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
+lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
 lean_dec(x_23);
 lean_dec(x_22);
 lean_dec(x_20);
@@ -2339,80 +2341,80 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
-x_132 = lean_ctor_get(x_89, 0);
-lean_inc(x_132);
-x_133 = lean_ctor_get(x_89, 1);
+x_133 = lean_ctor_get(x_90, 0);
 lean_inc(x_133);
-if (lean_is_exclusive(x_89)) {
- lean_ctor_release(x_89, 0);
- lean_ctor_release(x_89, 1);
- x_134 = x_89;
+x_134 = lean_ctor_get(x_90, 1);
+lean_inc(x_134);
+if (lean_is_exclusive(x_90)) {
+ lean_ctor_release(x_90, 0);
+ lean_ctor_release(x_90, 1);
+ x_135 = x_90;
 } else {
- lean_dec_ref(x_89);
- x_134 = lean_box(0);
+ lean_dec_ref(x_90);
+ x_135 = lean_box(0);
 }
-if (lean_is_scalar(x_134)) {
- x_135 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_135)) {
+ x_136 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_135 = x_134;
+ x_136 = x_135;
 }
-lean_ctor_set(x_135, 0, x_132);
-lean_ctor_set(x_135, 1, x_133);
-return x_135;
+lean_ctor_set(x_136, 0, x_133);
+lean_ctor_set(x_136, 1, x_134);
+return x_136;
 }
 }
 }
 else
 {
-lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; uint8_t x_145; 
+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; uint8_t x_146; 
 lean_dec(x_20);
 lean_dec(x_18);
 lean_dec(x_16);
 lean_dec(x_15);
-x_136 = lean_ctor_get(x_19, 1);
-lean_inc(x_136);
+x_137 = lean_ctor_get(x_19, 1);
+lean_inc(x_137);
 lean_dec(x_19);
-x_137 = lean_array_get_size(x_2);
-x_138 = l_Std_fmt___at_Lean_Position_instToFormatPosition___spec__1(x_137);
-x_139 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_139, 0, x_138);
-x_140 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__2;
-x_141 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_141, 0, x_140);
-lean_ctor_set(x_141, 1, x_139);
-x_142 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__4;
-x_143 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_143, 0, x_141);
-lean_ctor_set(x_143, 1, x_142);
-x_144 = l_Lean_throwError___at___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___spec__1(x_143, x_3, x_4, x_6, x_7, x_8, x_9, x_136);
+x_138 = lean_array_get_size(x_2);
+x_139 = l_Std_fmt___at_Lean_Position_instToFormatPosition___spec__1(x_138);
+x_140 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_140, 0, x_139);
+x_141 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__2;
+x_142 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_142, 0, x_141);
+lean_ctor_set(x_142, 1, x_140);
+x_143 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_elabDiscrsWitMatchType___spec__1___lambda__2___closed__4;
+x_144 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_144, 0, x_142);
+lean_ctor_set(x_144, 1, x_143);
+x_145 = l_Lean_throwError___at___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___spec__1(x_144, x_3, x_4, x_6, x_7, x_8, x_9, x_137);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
-x_145 = !lean_is_exclusive(x_144);
-if (x_145 == 0)
+x_146 = !lean_is_exclusive(x_145);
+if (x_146 == 0)
 {
-return x_144;
+return x_145;
 }
 else
 {
-lean_object* x_146; lean_object* x_147; lean_object* x_148; 
-x_146 = lean_ctor_get(x_144, 0);
-x_147 = lean_ctor_get(x_144, 1);
+lean_object* x_147; lean_object* x_148; lean_object* x_149; 
+x_147 = lean_ctor_get(x_145, 0);
+x_148 = lean_ctor_get(x_145, 1);
+lean_inc(x_148);
 lean_inc(x_147);
-lean_inc(x_146);
-lean_dec(x_144);
-x_148 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_148, 0, x_146);
-lean_ctor_set(x_148, 1, x_147);
-return x_148;
+lean_dec(x_145);
+x_149 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_149, 0, x_147);
+lean_ctor_set(x_149, 1, x_148);
+return x_149;
 }
 }
 }
 else
 {
-uint8_t x_149; 
+uint8_t x_150; 
 lean_dec(x_18);
 lean_dec(x_16);
 lean_dec(x_15);
@@ -2422,23 +2424,23 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
-x_149 = !lean_is_exclusive(x_19);
-if (x_149 == 0)
+x_150 = !lean_is_exclusive(x_19);
+if (x_150 == 0)
 {
 return x_19;
 }
 else
 {
-lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_150 = lean_ctor_get(x_19, 0);
-x_151 = lean_ctor_get(x_19, 1);
+lean_object* x_151; lean_object* x_152; lean_object* x_153; 
+x_151 = lean_ctor_get(x_19, 0);
+x_152 = lean_ctor_get(x_19, 1);
+lean_inc(x_152);
 lean_inc(x_151);
-lean_inc(x_150);
 lean_dec(x_19);
-x_152 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_152, 0, x_150);
-lean_ctor_set(x_152, 1, x_151);
-return x_152;
+x_153 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_153, 0, x_151);
+lean_ctor_set(x_153, 1, x_152);
+return x_153;
 }
 }
 }
@@ -4198,7 +4200,7 @@ else
 lean_object* x_35; lean_object* x_36; uint8_t x_37; 
 x_35 = l_Lean_Syntax_getArg(x_22, x_10);
 lean_dec(x_22);
-x_36 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_36 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_inc(x_35);
 x_37 = l_Lean_Syntax_isOfKind(x_35, x_36);
 if (x_37 == 0)
@@ -4282,7 +4284,7 @@ else
 lean_object* x_57; lean_object* x_58; uint8_t x_59; 
 x_57 = l_Lean_Syntax_getArg(x_44, x_10);
 lean_dec(x_44);
-x_58 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_58 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_inc(x_57);
 x_59 = l_Lean_Syntax_isOfKind(x_57, x_58);
 if (x_59 == 0)
@@ -4520,7 +4522,7 @@ lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32;
 x_29 = lean_unsigned_to_nat(0u);
 x_30 = l_Lean_Syntax_getArg(x_10, x_29);
 lean_dec(x_10);
-x_31 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_31 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_inc(x_30);
 x_32 = l_Lean_Syntax_isOfKind(x_30, x_31);
 if (x_32 == 0)
@@ -20043,7 +20045,7 @@ lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258;
 x_255 = lean_ctor_get(x_249, 1);
 lean_inc(x_255);
 lean_dec(x_249);
-x_256 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_256 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_257 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Match_0__Lean_Elab_Term_findDiscrRefinementPath_goIndex___spec__4(x_256, x_3, x_4, x_5, x_6, x_255);
 x_258 = lean_ctor_get(x_257, 0);
 lean_inc(x_258);
@@ -20094,7 +20096,7 @@ x_242 = l_Lean_KernelException_toMessageData___closed__15;
 x_243 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_243, 0, x_241);
 lean_ctor_set(x_243, 1, x_242);
-x_244 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_244 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_245 = l_Lean_addTrace___at___private_Lean_Elab_Match_0__Lean_Elab_Term_findDiscrRefinementPath_goIndex___spec__3(x_244, x_243, x_3, x_4, x_5, x_6, x_231);
 x_246 = lean_ctor_get(x_245, 0);
 lean_inc(x_246);
@@ -21242,7 +21244,7 @@ lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374;
 x_371 = lean_ctor_get(x_365, 1);
 lean_inc(x_371);
 lean_dec(x_365);
-x_372 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_372 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_373 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Match_0__Lean_Elab_Term_findDiscrRefinementPath_goIndex___spec__4(x_372, x_3, x_4, x_5, x_6, x_371);
 x_374 = lean_ctor_get(x_373, 0);
 lean_inc(x_374);
@@ -21293,7 +21295,7 @@ x_358 = l_Lean_KernelException_toMessageData___closed__15;
 x_359 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_359, 0, x_357);
 lean_ctor_set(x_359, 1, x_358);
-x_360 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_360 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_361 = l_Lean_addTrace___at___private_Lean_Elab_Match_0__Lean_Elab_Term_findDiscrRefinementPath_goIndex___spec__3(x_360, x_359, x_3, x_4, x_5, x_6, x_347);
 x_362 = lean_ctor_get(x_361, 0);
 lean_inc(x_362);
@@ -22755,7 +22757,7 @@ lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218;
 x_215 = lean_ctor_get(x_209, 1);
 lean_inc(x_215);
 lean_dec(x_209);
-x_216 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_216 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_217 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Match_0__Lean_Elab_Term_findDiscrRefinementPath_goIndex___spec__4(x_216, x_3, x_4, x_5, x_6, x_215);
 x_218 = lean_ctor_get(x_217, 0);
 lean_inc(x_218);
@@ -23723,7 +23725,7 @@ x_202 = l_Lean_KernelException_toMessageData___closed__15;
 x_203 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_203, 0, x_201);
 lean_ctor_set(x_203, 1, x_202);
-x_204 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_204 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_205 = l_Lean_addTrace___at___private_Lean_Elab_Match_0__Lean_Elab_Term_findDiscrRefinementPath_goIndex___spec__3(x_204, x_203, x_3, x_4, x_5, x_6, x_191);
 x_206 = lean_ctor_get(x_205, 0);
 lean_inc(x_206);
@@ -25806,7 +25808,7 @@ lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127;
 x_124 = lean_ctor_get(x_118, 1);
 lean_inc(x_124);
 lean_dec(x_118);
-x_125 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_125 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_126 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabPatterns___spec__4(x_125, x_6, x_7, x_8, x_9, x_10, x_11, x_124);
 x_127 = lean_ctor_get(x_126, 0);
 lean_inc(x_127);
@@ -25892,7 +25894,7 @@ x_111 = l_Lean_KernelException_toMessageData___closed__15;
 x_112 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_112, 0, x_110);
 lean_ctor_set(x_112, 1, x_111);
-x_113 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_113 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_114 = l_Lean_addTrace___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabPatterns___spec__3(x_113, x_112, x_6, x_7, x_8, x_9, x_10, x_11, x_103);
 x_115 = lean_ctor_get(x_114, 0);
 lean_inc(x_115);
@@ -36035,7 +36037,7 @@ lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136;
 x_133 = lean_ctor_get(x_127, 1);
 lean_inc(x_133);
 lean_dec(x_127);
-x_134 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_134 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_135 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_134, x_6, x_7, x_8, x_9, x_10, x_11, x_133);
 x_136 = lean_ctor_get(x_135, 0);
 lean_inc(x_136);
@@ -36128,7 +36130,7 @@ lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107;
 x_104 = lean_ctor_get(x_98, 1);
 lean_inc(x_104);
 lean_dec(x_98);
-x_105 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_105 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_106 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_105, x_6, x_7, x_8, x_9, x_10, x_11, x_104);
 x_107 = lean_ctor_get(x_106, 0);
 lean_inc(x_107);
@@ -36305,7 +36307,7 @@ x_92 = l_Lean_KernelException_toMessageData___closed__15;
 x_93 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_93, 0, x_91);
 lean_ctor_set(x_93, 1, x_92);
-x_94 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_94 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_95 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_94, x_93, x_6, x_7, x_8, x_9, x_10, x_11, x_88);
 x_96 = lean_ctor_get(x_95, 1);
 lean_inc(x_96);
@@ -36374,7 +36376,7 @@ x_121 = l_Lean_KernelException_toMessageData___closed__15;
 x_122 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_122, 0, x_120);
 lean_ctor_set(x_122, 1, x_121);
-x_123 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_123 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_124 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_123, x_122, x_6, x_7, x_8, x_9, x_10, x_11, x_116);
 x_125 = lean_ctor_get(x_124, 1);
 lean_inc(x_125);
@@ -36590,7 +36592,7 @@ lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267;
 x_264 = lean_ctor_get(x_258, 1);
 lean_inc(x_264);
 lean_dec(x_258);
-x_265 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_265 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_266 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_265, x_6, x_7, x_8, x_9, x_10, x_11, x_264);
 x_267 = lean_ctor_get(x_266, 0);
 lean_inc(x_267);
@@ -36683,7 +36685,7 @@ lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238;
 x_235 = lean_ctor_get(x_229, 1);
 lean_inc(x_235);
 lean_dec(x_229);
-x_236 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_236 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_237 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_236, x_6, x_7, x_8, x_9, x_10, x_11, x_235);
 x_238 = lean_ctor_get(x_237, 0);
 lean_inc(x_238);
@@ -36864,7 +36866,7 @@ x_223 = l_Lean_KernelException_toMessageData___closed__15;
 x_224 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_224, 0, x_222);
 lean_ctor_set(x_224, 1, x_223);
-x_225 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_225 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_226 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_225, x_224, x_6, x_7, x_8, x_9, x_10, x_11, x_219);
 x_227 = lean_ctor_get(x_226, 1);
 lean_inc(x_227);
@@ -36935,7 +36937,7 @@ x_252 = l_Lean_KernelException_toMessageData___closed__15;
 x_253 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_253, 0, x_251);
 lean_ctor_set(x_253, 1, x_252);
-x_254 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_254 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_255 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_254, x_253, x_6, x_7, x_8, x_9, x_10, x_11, x_247);
 x_256 = lean_ctor_get(x_255, 1);
 lean_inc(x_256);
@@ -37153,7 +37155,7 @@ lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396;
 x_393 = lean_ctor_get(x_387, 1);
 lean_inc(x_393);
 lean_dec(x_387);
-x_394 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_394 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_395 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_394, x_6, x_7, x_8, x_9, x_10, x_11, x_393);
 x_396 = lean_ctor_get(x_395, 0);
 lean_inc(x_396);
@@ -37246,7 +37248,7 @@ lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367;
 x_364 = lean_ctor_get(x_358, 1);
 lean_inc(x_364);
 lean_dec(x_358);
-x_365 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_365 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_366 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_365, x_6, x_7, x_8, x_9, x_10, x_11, x_364);
 x_367 = lean_ctor_get(x_366, 0);
 lean_inc(x_367);
@@ -37427,7 +37429,7 @@ x_352 = l_Lean_KernelException_toMessageData___closed__15;
 x_353 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_353, 0, x_351);
 lean_ctor_set(x_353, 1, x_352);
-x_354 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_354 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_355 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_354, x_353, x_6, x_7, x_8, x_9, x_10, x_11, x_348);
 x_356 = lean_ctor_get(x_355, 1);
 lean_inc(x_356);
@@ -37498,7 +37500,7 @@ x_381 = l_Lean_KernelException_toMessageData___closed__15;
 x_382 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_382, 0, x_380);
 lean_ctor_set(x_382, 1, x_381);
-x_383 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_383 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_384 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_383, x_382, x_6, x_7, x_8, x_9, x_10, x_11, x_376);
 x_385 = lean_ctor_get(x_384, 1);
 lean_inc(x_385);
@@ -37740,7 +37742,7 @@ lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529;
 x_526 = lean_ctor_get(x_520, 1);
 lean_inc(x_526);
 lean_dec(x_520);
-x_527 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_527 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_528 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_527, x_6, x_7, x_8, x_9, x_10, x_11, x_526);
 x_529 = lean_ctor_get(x_528, 0);
 lean_inc(x_529);
@@ -37833,7 +37835,7 @@ lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500;
 x_497 = lean_ctor_get(x_491, 1);
 lean_inc(x_497);
 lean_dec(x_491);
-x_498 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_498 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_499 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_498, x_6, x_7, x_8, x_9, x_10, x_11, x_497);
 x_500 = lean_ctor_get(x_499, 0);
 lean_inc(x_500);
@@ -38014,7 +38016,7 @@ x_485 = l_Lean_KernelException_toMessageData___closed__15;
 x_486 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_486, 0, x_484);
 lean_ctor_set(x_486, 1, x_485);
-x_487 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_487 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_488 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_487, x_486, x_6, x_7, x_8, x_9, x_10, x_11, x_481);
 x_489 = lean_ctor_get(x_488, 1);
 lean_inc(x_489);
@@ -38085,7 +38087,7 @@ x_514 = l_Lean_KernelException_toMessageData___closed__15;
 x_515 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_515, 0, x_513);
 lean_ctor_set(x_515, 1, x_514);
-x_516 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_516 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_517 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_516, x_515, x_6, x_7, x_8, x_9, x_10, x_11, x_509);
 x_518 = lean_ctor_get(x_517, 1);
 lean_inc(x_518);
diff --git a/stage0/stdlib/Lean/Elab/MutualDef.c b/stage0/stdlib/Lean/Elab/MutualDef.c
index f6f28c4431..d293c82858 100644
--- a/stage0/stdlib/Lean/Elab/MutualDef.c
+++ b/stage0/stdlib/Lean/Elab/MutualDef.c
@@ -422,6 +422,7 @@ lean_object* l_Array_getMax_x3f___at___private_Lean_Elab_MutualDef_0__Lean_Elab_
 extern lean_object* l_Lean_NameSet_empty;
 lean_object* l_Lean_Elab_expandDeclIdCore(lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_isExample___spec__1___boxed(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_object* l_Lean_Elab_Term_MutualClosure_Replacement_apply_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_elabAttr___at_Lean_Elab_Command_elabMutualDef___spec__4___lambda__1(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkInitialUsedFVarsMap___spec__1(lean_object*, size_t, size_t, lean_object*);
@@ -480,7 +481,6 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_levelMVarToParamH
 lean_object* l_List_forM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_collectUsed___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pickMaxFVar_x3f___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_mkHole(lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkModifiers___closed__2;
 lean_object* l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_instInhabitedDefViewElabHeader___closed__1;
@@ -5779,7 +5779,7 @@ else
 lean_object* x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; 
 x_49 = l_Lean_Syntax_getArg(x_43, x_12);
 lean_dec(x_43);
-x_50 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_50 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_inc(x_1);
 x_51 = lean_name_mk_string(x_1, x_50);
 lean_inc(x_49);
@@ -5881,7 +5881,7 @@ else
 lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; 
 x_73 = l_Lean_Syntax_getArg(x_67, x_12);
 lean_dec(x_67);
-x_74 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_74 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_inc(x_1);
 x_75 = lean_name_mk_string(x_1, x_74);
 lean_inc(x_73);
@@ -16147,7 +16147,7 @@ return x_116;
 }
 else
 {
-uint8_t x_117; uint8_t x_118; uint8_t x_119; uint8_t x_120; uint8_t x_121; uint8_t x_122; uint8_t x_123; uint8_t x_124; uint8_t x_125; lean_object* x_126; lean_object* x_127; 
+uint8_t x_117; uint8_t x_118; uint8_t x_119; uint8_t x_120; uint8_t x_121; uint8_t x_122; uint8_t x_123; uint8_t x_124; uint8_t x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; 
 x_117 = lean_ctor_get_uint8(x_36, 0);
 x_118 = lean_ctor_get_uint8(x_36, 1);
 x_119 = lean_ctor_get_uint8(x_36, 2);
@@ -16156,19 +16156,21 @@ x_121 = lean_ctor_get_uint8(x_36, 4);
 x_122 = lean_ctor_get_uint8(x_36, 5);
 x_123 = lean_ctor_get_uint8(x_36, 6);
 x_124 = lean_ctor_get_uint8(x_36, 8);
+x_125 = lean_ctor_get_uint8(x_36, 9);
 lean_dec(x_36);
-x_125 = 1;
-x_126 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_126, 0, x_117);
-lean_ctor_set_uint8(x_126, 1, x_118);
-lean_ctor_set_uint8(x_126, 2, x_119);
-lean_ctor_set_uint8(x_126, 3, x_120);
-lean_ctor_set_uint8(x_126, 4, x_121);
-lean_ctor_set_uint8(x_126, 5, x_122);
-lean_ctor_set_uint8(x_126, 6, x_123);
-lean_ctor_set_uint8(x_126, 7, x_125);
-lean_ctor_set_uint8(x_126, 8, x_124);
-lean_ctor_set(x_8, 0, x_126);
+x_126 = 1;
+x_127 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_127, 0, x_117);
+lean_ctor_set_uint8(x_127, 1, x_118);
+lean_ctor_set_uint8(x_127, 2, x_119);
+lean_ctor_set_uint8(x_127, 3, x_120);
+lean_ctor_set_uint8(x_127, 4, x_121);
+lean_ctor_set_uint8(x_127, 5, x_122);
+lean_ctor_set_uint8(x_127, 6, x_123);
+lean_ctor_set_uint8(x_127, 7, x_126);
+lean_ctor_set_uint8(x_127, 8, x_124);
+lean_ctor_set_uint8(x_127, 9, x_125);
+lean_ctor_set(x_8, 0, x_127);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
@@ -16176,181 +16178,181 @@ lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-x_127 = l_List_forM___at_Lean_Elab_Term_MutualClosure_main___spec__2(x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_37);
-if (lean_obj_tag(x_127) == 0)
+x_128 = l_List_forM___at_Lean_Elab_Term_MutualClosure_main___spec__2(x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_37);
+if (lean_obj_tag(x_128) == 0)
 {
-lean_object* x_128; lean_object* x_129; 
-x_128 = lean_ctor_get(x_127, 1);
-lean_inc(x_128);
-lean_dec(x_127);
+lean_object* x_129; lean_object* x_130; 
+x_129 = lean_ctor_get(x_128, 1);
+lean_inc(x_129);
+lean_dec(x_128);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-x_129 = l_List_mapM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__2(x_34, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_128);
+x_130 = l_List_mapM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__2(x_34, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_129);
 lean_dec(x_34);
-if (lean_obj_tag(x_129) == 0)
+if (lean_obj_tag(x_130) == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; size_t x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; 
-x_130 = lean_ctor_get(x_129, 0);
-lean_inc(x_130);
-x_131 = lean_ctor_get(x_129, 1);
+lean_object* x_131; lean_object* x_132; lean_object* x_133; size_t x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
+x_131 = lean_ctor_get(x_130, 0);
 lean_inc(x_131);
-lean_dec(x_129);
-x_132 = lean_array_get_size(x_4);
-x_133 = lean_usize_of_nat(x_132);
-lean_dec(x_132);
-x_134 = x_4;
-x_135 = lean_box_usize(x_133);
-x_136 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
-x_137 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__3___boxed), 10, 3);
-lean_closure_set(x_137, 0, x_135);
-lean_closure_set(x_137, 1, x_136);
-lean_closure_set(x_137, 2, x_134);
-x_138 = x_137;
+x_132 = lean_ctor_get(x_130, 1);
+lean_inc(x_132);
+lean_dec(x_130);
+x_133 = lean_array_get_size(x_4);
+x_134 = lean_usize_of_nat(x_133);
+lean_dec(x_133);
+x_135 = x_4;
+x_136 = lean_box_usize(x_134);
+x_137 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
+x_138 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__3___boxed), 10, 3);
+lean_closure_set(x_138, 0, x_136);
+lean_closure_set(x_138, 1, x_137);
+lean_closure_set(x_138, 2, x_135);
+x_139 = x_138;
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-x_139 = lean_apply_7(x_138, x_6, x_7, x_8, x_9, x_10, x_11, x_131);
-if (lean_obj_tag(x_139) == 0)
+x_140 = lean_apply_7(x_139, x_6, x_7, x_8, x_9, x_10, x_11, x_132);
+if (lean_obj_tag(x_140) == 0)
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; size_t 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; 
-x_140 = lean_ctor_get(x_139, 0);
-lean_inc(x_140);
-x_141 = lean_ctor_get(x_139, 1);
+lean_object* x_141; lean_object* x_142; lean_object* x_143; size_t 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_141 = lean_ctor_get(x_140, 0);
 lean_inc(x_141);
-lean_dec(x_139);
-x_142 = lean_array_get_size(x_2);
-x_143 = lean_usize_of_nat(x_142);
-lean_dec(x_142);
-x_144 = x_2;
-x_145 = lean_box_usize(x_143);
-x_146 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
-x_147 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__4___boxed), 10, 3);
-lean_closure_set(x_147, 0, x_145);
-lean_closure_set(x_147, 1, x_146);
-lean_closure_set(x_147, 2, x_144);
-x_148 = x_147;
+x_142 = lean_ctor_get(x_140, 1);
+lean_inc(x_142);
+lean_dec(x_140);
+x_143 = lean_array_get_size(x_2);
+x_144 = lean_usize_of_nat(x_143);
+lean_dec(x_143);
+x_145 = x_2;
+x_146 = lean_box_usize(x_144);
+x_147 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
+x_148 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__4___boxed), 10, 3);
+lean_closure_set(x_148, 0, x_146);
+lean_closure_set(x_148, 1, x_147);
+lean_closure_set(x_148, 2, x_145);
+x_149 = x_148;
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-x_149 = lean_apply_7(x_148, x_6, x_7, x_8, x_9, x_10, x_11, x_141);
-if (lean_obj_tag(x_149) == 0)
+x_150 = lean_apply_7(x_149, x_6, x_7, x_8, x_9, x_10, x_11, x_142);
+if (lean_obj_tag(x_150) == 0)
 {
-lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_150 = lean_ctor_get(x_149, 0);
-lean_inc(x_150);
-x_151 = lean_ctor_get(x_149, 1);
+lean_object* x_151; lean_object* x_152; lean_object* x_153; 
+x_151 = lean_ctor_get(x_150, 0);
 lean_inc(x_151);
-lean_dec(x_149);
+x_152 = lean_ctor_get(x_150, 1);
+lean_inc(x_152);
+lean_dec(x_150);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
-x_152 = l_List_mapM___at_Lean_Elab_Term_MutualClosure_main___spec__5(x_130, x_6, x_7, x_8, x_9, x_10, x_11, x_151);
-if (lean_obj_tag(x_152) == 0)
+x_153 = l_List_mapM___at_Lean_Elab_Term_MutualClosure_main___spec__5(x_131, x_6, x_7, x_8, x_9, x_10, x_11, x_152);
+if (lean_obj_tag(x_153) == 0)
 {
-lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; size_t x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; size_t x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; uint8_t x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; 
-x_153 = lean_ctor_get(x_152, 0);
-lean_inc(x_153);
-x_154 = lean_ctor_get(x_152, 1);
+lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; size_t x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; size_t x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; 
+x_154 = lean_ctor_get(x_153, 0);
 lean_inc(x_154);
-lean_dec(x_152);
-x_155 = lean_box(0);
-x_156 = l_Lean_Elab_Term_MutualClosure_insertReplacementForMainFns(x_155, x_1, x_150, x_3);
-lean_inc(x_153);
-x_157 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_insertReplacementForLetRecs___spec__1(x_156, x_153);
-x_158 = lean_array_get_size(x_140);
-x_159 = lean_usize_of_nat(x_158);
+x_155 = lean_ctor_get(x_153, 1);
+lean_inc(x_155);
+lean_dec(x_153);
+x_156 = lean_box(0);
+x_157 = l_Lean_Elab_Term_MutualClosure_insertReplacementForMainFns(x_156, x_1, x_151, x_3);
+lean_inc(x_154);
+x_158 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_insertReplacementForLetRecs___spec__1(x_157, x_154);
+x_159 = lean_array_get_size(x_141);
+x_160 = lean_usize_of_nat(x_159);
+lean_dec(x_159);
+x_161 = x_141;
+lean_inc(x_154);
+x_162 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__6(x_1, x_3, x_151, x_154, x_160, x_15, x_161);
+lean_dec(x_3);
+x_163 = x_162;
+x_164 = lean_array_get_size(x_151);
+x_165 = lean_usize_of_nat(x_164);
+lean_dec(x_164);
+x_166 = x_151;
+x_167 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__7(x_158, x_165, x_15, x_166);
+x_168 = x_167;
+x_169 = l_List_map___at_Lean_Elab_Term_MutualClosure_main___spec__8(x_158, x_154);
 lean_dec(x_158);
-x_160 = x_140;
-lean_inc(x_153);
-x_161 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__6(x_1, x_3, x_150, x_153, x_159, x_15, x_160);
-lean_dec(x_3);
-x_162 = x_161;
-x_163 = lean_array_get_size(x_150);
-x_164 = lean_usize_of_nat(x_163);
+x_170 = l_Lean_Elab_Term_MutualClosure_getKindForLetRecs(x_168);
+x_171 = l_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs(x_168);
+x_172 = l_Array_empty___closed__1;
+x_173 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_pushLetRecs___spec__1(x_170, x_171, x_172, x_169);
+lean_dec(x_171);
+x_174 = l_Lean_Elab_Term_MutualClosure_pushMain(x_173, x_1, x_168, x_163, x_6, x_7, x_8, x_9, x_10, x_11, x_155);
+lean_dec(x_11);
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_163);
-x_165 = x_150;
-x_166 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__7(x_157, x_164, x_15, x_165);
-x_167 = x_166;
-x_168 = l_List_map___at_Lean_Elab_Term_MutualClosure_main___spec__8(x_157, x_153);
-lean_dec(x_157);
-x_169 = l_Lean_Elab_Term_MutualClosure_getKindForLetRecs(x_167);
-x_170 = l_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs(x_167);
-x_171 = l_Array_empty___closed__1;
-x_172 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_pushLetRecs___spec__1(x_169, x_170, x_171, x_168);
-lean_dec(x_170);
-x_173 = l_Lean_Elab_Term_MutualClosure_pushMain(x_172, x_1, x_167, x_162, x_6, x_7, x_8, x_9, x_10, x_11, x_154);
-lean_dec(x_11);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_162);
-lean_dec(x_167);
-if (lean_obj_tag(x_173) == 0)
+lean_dec(x_168);
+if (lean_obj_tag(x_174) == 0)
 {
-lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; 
-x_174 = lean_ctor_get(x_173, 0);
-lean_inc(x_174);
-x_175 = lean_ctor_get(x_173, 1);
+lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; 
+x_175 = lean_ctor_get(x_174, 0);
 lean_inc(x_175);
-if (lean_is_exclusive(x_173)) {
- lean_ctor_release(x_173, 0);
- lean_ctor_release(x_173, 1);
- x_176 = x_173;
+x_176 = lean_ctor_get(x_174, 1);
+lean_inc(x_176);
+if (lean_is_exclusive(x_174)) {
+ lean_ctor_release(x_174, 0);
+ lean_ctor_release(x_174, 1);
+ x_177 = x_174;
 } else {
- lean_dec_ref(x_173);
- x_176 = lean_box(0);
+ lean_dec_ref(x_174);
+ x_177 = lean_box(0);
 }
-if (lean_is_scalar(x_176)) {
- x_177 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_177)) {
+ x_178 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_177 = x_176;
+ x_178 = x_177;
 }
-lean_ctor_set(x_177, 0, x_174);
-lean_ctor_set(x_177, 1, x_175);
-return x_177;
+lean_ctor_set(x_178, 0, x_175);
+lean_ctor_set(x_178, 1, x_176);
+return x_178;
 }
 else
 {
-lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; 
-x_178 = lean_ctor_get(x_173, 0);
-lean_inc(x_178);
-x_179 = lean_ctor_get(x_173, 1);
+lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; 
+x_179 = lean_ctor_get(x_174, 0);
 lean_inc(x_179);
-if (lean_is_exclusive(x_173)) {
- lean_ctor_release(x_173, 0);
- lean_ctor_release(x_173, 1);
- x_180 = x_173;
+x_180 = lean_ctor_get(x_174, 1);
+lean_inc(x_180);
+if (lean_is_exclusive(x_174)) {
+ lean_ctor_release(x_174, 0);
+ lean_ctor_release(x_174, 1);
+ x_181 = x_174;
 } else {
- lean_dec_ref(x_173);
- x_180 = lean_box(0);
+ lean_dec_ref(x_174);
+ x_181 = lean_box(0);
 }
-if (lean_is_scalar(x_180)) {
- x_181 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_181)) {
+ x_182 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_181 = x_180;
+ x_182 = x_181;
 }
-lean_ctor_set(x_181, 0, x_178);
-lean_ctor_set(x_181, 1, x_179);
-return x_181;
+lean_ctor_set(x_182, 0, x_179);
+lean_ctor_set(x_182, 1, x_180);
+return x_182;
 }
 }
 else
 {
-lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; 
-lean_dec(x_150);
-lean_dec(x_140);
+lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; 
+lean_dec(x_151);
+lean_dec(x_141);
 lean_dec(x_8);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -16359,33 +16361,33 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_1);
-x_182 = lean_ctor_get(x_152, 0);
-lean_inc(x_182);
-x_183 = lean_ctor_get(x_152, 1);
+x_183 = lean_ctor_get(x_153, 0);
 lean_inc(x_183);
-if (lean_is_exclusive(x_152)) {
- lean_ctor_release(x_152, 0);
- lean_ctor_release(x_152, 1);
- x_184 = x_152;
+x_184 = lean_ctor_get(x_153, 1);
+lean_inc(x_184);
+if (lean_is_exclusive(x_153)) {
+ lean_ctor_release(x_153, 0);
+ lean_ctor_release(x_153, 1);
+ x_185 = x_153;
 } else {
- lean_dec_ref(x_152);
- x_184 = lean_box(0);
+ lean_dec_ref(x_153);
+ x_185 = lean_box(0);
 }
-if (lean_is_scalar(x_184)) {
- x_185 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_185)) {
+ x_186 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_185 = x_184;
+ x_186 = x_185;
 }
-lean_ctor_set(x_185, 0, x_182);
-lean_ctor_set(x_185, 1, x_183);
-return x_185;
+lean_ctor_set(x_186, 0, x_183);
+lean_ctor_set(x_186, 1, x_184);
+return x_186;
 }
 }
 else
 {
-lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; 
-lean_dec(x_140);
-lean_dec(x_130);
+lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; 
+lean_dec(x_141);
+lean_dec(x_131);
 lean_dec(x_8);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -16394,32 +16396,32 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_1);
-x_186 = lean_ctor_get(x_149, 0);
-lean_inc(x_186);
-x_187 = lean_ctor_get(x_149, 1);
+x_187 = lean_ctor_get(x_150, 0);
 lean_inc(x_187);
-if (lean_is_exclusive(x_149)) {
- lean_ctor_release(x_149, 0);
- lean_ctor_release(x_149, 1);
- x_188 = x_149;
+x_188 = lean_ctor_get(x_150, 1);
+lean_inc(x_188);
+if (lean_is_exclusive(x_150)) {
+ lean_ctor_release(x_150, 0);
+ lean_ctor_release(x_150, 1);
+ x_189 = x_150;
 } else {
- lean_dec_ref(x_149);
- x_188 = lean_box(0);
+ lean_dec_ref(x_150);
+ x_189 = lean_box(0);
 }
-if (lean_is_scalar(x_188)) {
- x_189 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_189)) {
+ x_190 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_189 = x_188;
+ x_190 = x_189;
 }
-lean_ctor_set(x_189, 0, x_186);
-lean_ctor_set(x_189, 1, x_187);
-return x_189;
+lean_ctor_set(x_190, 0, x_187);
+lean_ctor_set(x_190, 1, x_188);
+return x_190;
 }
 }
 else
 {
-lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; 
-lean_dec(x_130);
+lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; 
+lean_dec(x_131);
 lean_dec(x_8);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -16429,31 +16431,31 @@ lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_190 = lean_ctor_get(x_139, 0);
-lean_inc(x_190);
-x_191 = lean_ctor_get(x_139, 1);
+x_191 = lean_ctor_get(x_140, 0);
 lean_inc(x_191);
-if (lean_is_exclusive(x_139)) {
- lean_ctor_release(x_139, 0);
- lean_ctor_release(x_139, 1);
- x_192 = x_139;
+x_192 = lean_ctor_get(x_140, 1);
+lean_inc(x_192);
+if (lean_is_exclusive(x_140)) {
+ lean_ctor_release(x_140, 0);
+ lean_ctor_release(x_140, 1);
+ x_193 = x_140;
 } else {
- lean_dec_ref(x_139);
- x_192 = lean_box(0);
+ lean_dec_ref(x_140);
+ x_193 = lean_box(0);
 }
-if (lean_is_scalar(x_192)) {
- x_193 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_193)) {
+ x_194 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_193 = x_192;
+ x_194 = x_193;
 }
-lean_ctor_set(x_193, 0, x_190);
-lean_ctor_set(x_193, 1, x_191);
-return x_193;
+lean_ctor_set(x_194, 0, x_191);
+lean_ctor_set(x_194, 1, x_192);
+return x_194;
 }
 }
 else
 {
-lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; 
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; 
 lean_dec(x_8);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -16464,31 +16466,31 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_194 = lean_ctor_get(x_129, 0);
-lean_inc(x_194);
-x_195 = lean_ctor_get(x_129, 1);
+x_195 = lean_ctor_get(x_130, 0);
 lean_inc(x_195);
-if (lean_is_exclusive(x_129)) {
- lean_ctor_release(x_129, 0);
- lean_ctor_release(x_129, 1);
- x_196 = x_129;
+x_196 = lean_ctor_get(x_130, 1);
+lean_inc(x_196);
+if (lean_is_exclusive(x_130)) {
+ lean_ctor_release(x_130, 0);
+ lean_ctor_release(x_130, 1);
+ x_197 = x_130;
 } else {
- lean_dec_ref(x_129);
- x_196 = lean_box(0);
+ lean_dec_ref(x_130);
+ x_197 = lean_box(0);
 }
-if (lean_is_scalar(x_196)) {
- x_197 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_197)) {
+ x_198 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_197 = x_196;
+ x_198 = x_197;
 }
-lean_ctor_set(x_197, 0, x_194);
-lean_ctor_set(x_197, 1, x_195);
-return x_197;
+lean_ctor_set(x_198, 0, x_195);
+lean_ctor_set(x_198, 1, x_196);
+return x_198;
 }
 }
 else
 {
-lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; 
+lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; 
 lean_dec(x_8);
 lean_dec(x_34);
 lean_dec(x_11);
@@ -16501,256 +16503,258 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_198 = lean_ctor_get(x_127, 0);
-lean_inc(x_198);
-x_199 = lean_ctor_get(x_127, 1);
+x_199 = lean_ctor_get(x_128, 0);
 lean_inc(x_199);
-if (lean_is_exclusive(x_127)) {
- lean_ctor_release(x_127, 0);
- lean_ctor_release(x_127, 1);
- x_200 = x_127;
+x_200 = lean_ctor_get(x_128, 1);
+lean_inc(x_200);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ x_201 = x_128;
 } else {
- lean_dec_ref(x_127);
- x_200 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_201 = lean_box(0);
 }
-if (lean_is_scalar(x_200)) {
- x_201 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_201)) {
+ x_202 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_201 = x_200;
+ x_202 = x_201;
 }
-lean_ctor_set(x_201, 0, x_198);
-lean_ctor_set(x_201, 1, x_199);
-return x_201;
+lean_ctor_set(x_202, 0, x_199);
+lean_ctor_set(x_202, 1, x_200);
+return x_202;
 }
 }
 }
 else
 {
-lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; uint8_t x_206; uint8_t x_207; uint8_t x_208; uint8_t x_209; uint8_t x_210; uint8_t x_211; uint8_t x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; 
-x_202 = lean_ctor_get(x_8, 1);
-x_203 = lean_ctor_get(x_8, 2);
-x_204 = lean_ctor_get(x_8, 3);
+lean_object* x_203; lean_object* x_204; lean_object* x_205; uint8_t x_206; uint8_t x_207; uint8_t x_208; uint8_t x_209; uint8_t x_210; uint8_t x_211; uint8_t x_212; uint8_t x_213; uint8_t x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; 
+x_203 = lean_ctor_get(x_8, 1);
+x_204 = lean_ctor_get(x_8, 2);
+x_205 = lean_ctor_get(x_8, 3);
+lean_inc(x_205);
 lean_inc(x_204);
 lean_inc(x_203);
-lean_inc(x_202);
 lean_dec(x_8);
-x_205 = lean_ctor_get_uint8(x_36, 0);
-x_206 = lean_ctor_get_uint8(x_36, 1);
-x_207 = lean_ctor_get_uint8(x_36, 2);
-x_208 = lean_ctor_get_uint8(x_36, 3);
-x_209 = lean_ctor_get_uint8(x_36, 4);
-x_210 = lean_ctor_get_uint8(x_36, 5);
-x_211 = lean_ctor_get_uint8(x_36, 6);
-x_212 = lean_ctor_get_uint8(x_36, 8);
+x_206 = lean_ctor_get_uint8(x_36, 0);
+x_207 = lean_ctor_get_uint8(x_36, 1);
+x_208 = lean_ctor_get_uint8(x_36, 2);
+x_209 = lean_ctor_get_uint8(x_36, 3);
+x_210 = lean_ctor_get_uint8(x_36, 4);
+x_211 = lean_ctor_get_uint8(x_36, 5);
+x_212 = lean_ctor_get_uint8(x_36, 6);
+x_213 = lean_ctor_get_uint8(x_36, 8);
+x_214 = lean_ctor_get_uint8(x_36, 9);
 if (lean_is_exclusive(x_36)) {
- x_213 = x_36;
+ x_215 = x_36;
 } else {
  lean_dec_ref(x_36);
- x_213 = lean_box(0);
+ x_215 = lean_box(0);
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(0, 0, 9);
+x_216 = 1;
+if (lean_is_scalar(x_215)) {
+ x_217 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_215 = x_213;
+ x_217 = x_215;
 }
-lean_ctor_set_uint8(x_215, 0, x_205);
-lean_ctor_set_uint8(x_215, 1, x_206);
-lean_ctor_set_uint8(x_215, 2, x_207);
-lean_ctor_set_uint8(x_215, 3, x_208);
-lean_ctor_set_uint8(x_215, 4, x_209);
-lean_ctor_set_uint8(x_215, 5, x_210);
-lean_ctor_set_uint8(x_215, 6, x_211);
-lean_ctor_set_uint8(x_215, 7, x_214);
-lean_ctor_set_uint8(x_215, 8, x_212);
-x_216 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_216, 0, x_215);
-lean_ctor_set(x_216, 1, x_202);
-lean_ctor_set(x_216, 2, x_203);
-lean_ctor_set(x_216, 3, x_204);
+lean_ctor_set_uint8(x_217, 0, x_206);
+lean_ctor_set_uint8(x_217, 1, x_207);
+lean_ctor_set_uint8(x_217, 2, x_208);
+lean_ctor_set_uint8(x_217, 3, x_209);
+lean_ctor_set_uint8(x_217, 4, x_210);
+lean_ctor_set_uint8(x_217, 5, x_211);
+lean_ctor_set_uint8(x_217, 6, x_212);
+lean_ctor_set_uint8(x_217, 7, x_216);
+lean_ctor_set_uint8(x_217, 8, x_213);
+lean_ctor_set_uint8(x_217, 9, x_214);
+x_218 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_218, 0, x_217);
+lean_ctor_set(x_218, 1, x_203);
+lean_ctor_set(x_218, 2, x_204);
+lean_ctor_set(x_218, 3, x_205);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_216);
+lean_inc(x_218);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-x_217 = l_List_forM___at_Lean_Elab_Term_MutualClosure_main___spec__2(x_5, x_6, x_7, x_216, x_9, x_10, x_11, x_37);
-if (lean_obj_tag(x_217) == 0)
-{
-lean_object* x_218; lean_object* x_219; 
-x_218 = lean_ctor_get(x_217, 1);
-lean_inc(x_218);
-lean_dec(x_217);
-lean_inc(x_11);
-lean_inc(x_10);
-lean_inc(x_9);
-lean_inc(x_216);
-lean_inc(x_7);
-lean_inc(x_6);
-x_219 = l_List_mapM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__2(x_34, x_5, x_6, x_7, x_216, x_9, x_10, x_11, x_218);
-lean_dec(x_34);
+x_219 = l_List_forM___at_Lean_Elab_Term_MutualClosure_main___spec__2(x_5, x_6, x_7, x_218, x_9, x_10, x_11, x_37);
 if (lean_obj_tag(x_219) == 0)
 {
-lean_object* x_220; lean_object* x_221; lean_object* x_222; size_t x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; 
-x_220 = lean_ctor_get(x_219, 0);
+lean_object* x_220; lean_object* x_221; 
+x_220 = lean_ctor_get(x_219, 1);
 lean_inc(x_220);
-x_221 = lean_ctor_get(x_219, 1);
-lean_inc(x_221);
 lean_dec(x_219);
-x_222 = lean_array_get_size(x_4);
-x_223 = lean_usize_of_nat(x_222);
-lean_dec(x_222);
-x_224 = x_4;
-x_225 = lean_box_usize(x_223);
-x_226 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
-x_227 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__3___boxed), 10, 3);
-lean_closure_set(x_227, 0, x_225);
-lean_closure_set(x_227, 1, x_226);
-lean_closure_set(x_227, 2, x_224);
-x_228 = x_227;
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_216);
+lean_inc(x_218);
 lean_inc(x_7);
 lean_inc(x_6);
-x_229 = lean_apply_7(x_228, x_6, x_7, x_216, x_9, x_10, x_11, x_221);
-if (lean_obj_tag(x_229) == 0)
+x_221 = l_List_mapM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__2(x_34, x_5, x_6, x_7, x_218, x_9, x_10, x_11, x_220);
+lean_dec(x_34);
+if (lean_obj_tag(x_221) == 0)
 {
-lean_object* x_230; lean_object* x_231; lean_object* x_232; size_t x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; 
-x_230 = lean_ctor_get(x_229, 0);
-lean_inc(x_230);
-x_231 = lean_ctor_get(x_229, 1);
-lean_inc(x_231);
-lean_dec(x_229);
-x_232 = lean_array_get_size(x_2);
-x_233 = lean_usize_of_nat(x_232);
-lean_dec(x_232);
-x_234 = x_2;
-x_235 = lean_box_usize(x_233);
-x_236 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
-x_237 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__4___boxed), 10, 3);
-lean_closure_set(x_237, 0, x_235);
-lean_closure_set(x_237, 1, x_236);
-lean_closure_set(x_237, 2, x_234);
-x_238 = x_237;
+lean_object* x_222; lean_object* x_223; lean_object* x_224; size_t x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; 
+x_222 = lean_ctor_get(x_221, 0);
+lean_inc(x_222);
+x_223 = lean_ctor_get(x_221, 1);
+lean_inc(x_223);
+lean_dec(x_221);
+x_224 = lean_array_get_size(x_4);
+x_225 = lean_usize_of_nat(x_224);
+lean_dec(x_224);
+x_226 = x_4;
+x_227 = lean_box_usize(x_225);
+x_228 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
+x_229 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__3___boxed), 10, 3);
+lean_closure_set(x_229, 0, x_227);
+lean_closure_set(x_229, 1, x_228);
+lean_closure_set(x_229, 2, x_226);
+x_230 = x_229;
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_216);
+lean_inc(x_218);
 lean_inc(x_7);
 lean_inc(x_6);
-x_239 = lean_apply_7(x_238, x_6, x_7, x_216, x_9, x_10, x_11, x_231);
-if (lean_obj_tag(x_239) == 0)
+x_231 = lean_apply_7(x_230, x_6, x_7, x_218, x_9, x_10, x_11, x_223);
+if (lean_obj_tag(x_231) == 0)
 {
-lean_object* x_240; lean_object* x_241; lean_object* x_242; 
-x_240 = lean_ctor_get(x_239, 0);
-lean_inc(x_240);
-x_241 = lean_ctor_get(x_239, 1);
-lean_inc(x_241);
-lean_dec(x_239);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; size_t x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; 
+x_232 = lean_ctor_get(x_231, 0);
+lean_inc(x_232);
+x_233 = lean_ctor_get(x_231, 1);
+lean_inc(x_233);
+lean_dec(x_231);
+x_234 = lean_array_get_size(x_2);
+x_235 = lean_usize_of_nat(x_234);
+lean_dec(x_234);
+x_236 = x_2;
+x_237 = lean_box_usize(x_235);
+x_238 = l_Lean_Elab_Term_MutualClosure_main___boxed__const__1;
+x_239 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__4___boxed), 10, 3);
+lean_closure_set(x_239, 0, x_237);
+lean_closure_set(x_239, 1, x_238);
+lean_closure_set(x_239, 2, x_236);
+x_240 = x_239;
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_216);
-x_242 = l_List_mapM___at_Lean_Elab_Term_MutualClosure_main___spec__5(x_220, x_6, x_7, x_216, x_9, x_10, x_11, x_241);
-if (lean_obj_tag(x_242) == 0)
+lean_inc(x_218);
+lean_inc(x_7);
+lean_inc(x_6);
+x_241 = lean_apply_7(x_240, x_6, x_7, x_218, x_9, x_10, x_11, x_233);
+if (lean_obj_tag(x_241) == 0)
 {
-lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; size_t x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; size_t x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; uint8_t x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; 
-x_243 = lean_ctor_get(x_242, 0);
+lean_object* x_242; lean_object* x_243; lean_object* x_244; 
+x_242 = lean_ctor_get(x_241, 0);
+lean_inc(x_242);
+x_243 = lean_ctor_get(x_241, 1);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_242, 1);
-lean_inc(x_244);
+lean_dec(x_241);
+lean_inc(x_11);
+lean_inc(x_10);
+lean_inc(x_9);
+lean_inc(x_218);
+x_244 = l_List_mapM___at_Lean_Elab_Term_MutualClosure_main___spec__5(x_222, x_6, x_7, x_218, x_9, x_10, x_11, x_243);
+if (lean_obj_tag(x_244) == 0)
+{
+lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; size_t x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; size_t x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; uint8_t x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; 
+x_245 = lean_ctor_get(x_244, 0);
+lean_inc(x_245);
+x_246 = lean_ctor_get(x_244, 1);
+lean_inc(x_246);
+lean_dec(x_244);
+x_247 = lean_box(0);
+x_248 = l_Lean_Elab_Term_MutualClosure_insertReplacementForMainFns(x_247, x_1, x_242, x_3);
+lean_inc(x_245);
+x_249 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_insertReplacementForLetRecs___spec__1(x_248, x_245);
+x_250 = lean_array_get_size(x_232);
+x_251 = lean_usize_of_nat(x_250);
+lean_dec(x_250);
+x_252 = x_232;
+lean_inc(x_245);
+x_253 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__6(x_1, x_3, x_242, x_245, x_251, x_15, x_252);
+lean_dec(x_3);
+x_254 = x_253;
+x_255 = lean_array_get_size(x_242);
+x_256 = lean_usize_of_nat(x_255);
+lean_dec(x_255);
+x_257 = x_242;
+x_258 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__7(x_249, x_256, x_15, x_257);
+x_259 = x_258;
+x_260 = l_List_map___at_Lean_Elab_Term_MutualClosure_main___spec__8(x_249, x_245);
+lean_dec(x_249);
+x_261 = l_Lean_Elab_Term_MutualClosure_getKindForLetRecs(x_259);
+x_262 = l_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs(x_259);
+x_263 = l_Array_empty___closed__1;
+x_264 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_pushLetRecs___spec__1(x_261, x_262, x_263, x_260);
+lean_dec(x_262);
+x_265 = l_Lean_Elab_Term_MutualClosure_pushMain(x_264, x_1, x_259, x_254, x_6, x_7, x_218, x_9, x_10, x_11, x_246);
+lean_dec(x_11);
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_254);
+lean_dec(x_259);
+if (lean_obj_tag(x_265) == 0)
+{
+lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; 
+x_266 = lean_ctor_get(x_265, 0);
+lean_inc(x_266);
+x_267 = lean_ctor_get(x_265, 1);
+lean_inc(x_267);
+if (lean_is_exclusive(x_265)) {
+ lean_ctor_release(x_265, 0);
+ lean_ctor_release(x_265, 1);
+ x_268 = x_265;
+} else {
+ lean_dec_ref(x_265);
+ x_268 = lean_box(0);
+}
+if (lean_is_scalar(x_268)) {
+ x_269 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_269 = x_268;
+}
+lean_ctor_set(x_269, 0, x_266);
+lean_ctor_set(x_269, 1, x_267);
+return x_269;
+}
+else
+{
+lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; 
+x_270 = lean_ctor_get(x_265, 0);
+lean_inc(x_270);
+x_271 = lean_ctor_get(x_265, 1);
+lean_inc(x_271);
+if (lean_is_exclusive(x_265)) {
+ lean_ctor_release(x_265, 0);
+ lean_ctor_release(x_265, 1);
+ x_272 = x_265;
+} else {
+ lean_dec_ref(x_265);
+ x_272 = lean_box(0);
+}
+if (lean_is_scalar(x_272)) {
+ x_273 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_273 = x_272;
+}
+lean_ctor_set(x_273, 0, x_270);
+lean_ctor_set(x_273, 1, x_271);
+return x_273;
+}
+}
+else
+{
+lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; 
 lean_dec(x_242);
-x_245 = lean_box(0);
-x_246 = l_Lean_Elab_Term_MutualClosure_insertReplacementForMainFns(x_245, x_1, x_240, x_3);
-lean_inc(x_243);
-x_247 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_insertReplacementForLetRecs___spec__1(x_246, x_243);
-x_248 = lean_array_get_size(x_230);
-x_249 = lean_usize_of_nat(x_248);
-lean_dec(x_248);
-x_250 = x_230;
-lean_inc(x_243);
-x_251 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__6(x_1, x_3, x_240, x_243, x_249, x_15, x_250);
-lean_dec(x_3);
-x_252 = x_251;
-x_253 = lean_array_get_size(x_240);
-x_254 = lean_usize_of_nat(x_253);
-lean_dec(x_253);
-x_255 = x_240;
-x_256 = l_Array_mapMUnsafe_map___at_Lean_Elab_Term_MutualClosure_main___spec__7(x_247, x_254, x_15, x_255);
-x_257 = x_256;
-x_258 = l_List_map___at_Lean_Elab_Term_MutualClosure_main___spec__8(x_247, x_243);
-lean_dec(x_247);
-x_259 = l_Lean_Elab_Term_MutualClosure_getKindForLetRecs(x_257);
-x_260 = l_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs(x_257);
-x_261 = l_Array_empty___closed__1;
-x_262 = l_List_foldl___at_Lean_Elab_Term_MutualClosure_pushLetRecs___spec__1(x_259, x_260, x_261, x_258);
-lean_dec(x_260);
-x_263 = l_Lean_Elab_Term_MutualClosure_pushMain(x_262, x_1, x_257, x_252, x_6, x_7, x_216, x_9, x_10, x_11, x_244);
-lean_dec(x_11);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_252);
-lean_dec(x_257);
-if (lean_obj_tag(x_263) == 0)
-{
-lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; 
-x_264 = lean_ctor_get(x_263, 0);
-lean_inc(x_264);
-x_265 = lean_ctor_get(x_263, 1);
-lean_inc(x_265);
-if (lean_is_exclusive(x_263)) {
- lean_ctor_release(x_263, 0);
- lean_ctor_release(x_263, 1);
- x_266 = x_263;
-} else {
- lean_dec_ref(x_263);
- x_266 = lean_box(0);
-}
-if (lean_is_scalar(x_266)) {
- x_267 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_267 = x_266;
-}
-lean_ctor_set(x_267, 0, x_264);
-lean_ctor_set(x_267, 1, x_265);
-return x_267;
-}
-else
-{
-lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; 
-x_268 = lean_ctor_get(x_263, 0);
-lean_inc(x_268);
-x_269 = lean_ctor_get(x_263, 1);
-lean_inc(x_269);
-if (lean_is_exclusive(x_263)) {
- lean_ctor_release(x_263, 0);
- lean_ctor_release(x_263, 1);
- x_270 = x_263;
-} else {
- lean_dec_ref(x_263);
- x_270 = lean_box(0);
-}
-if (lean_is_scalar(x_270)) {
- x_271 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_271 = x_270;
-}
-lean_ctor_set(x_271, 0, x_268);
-lean_ctor_set(x_271, 1, x_269);
-return x_271;
-}
-}
-else
-{
-lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; 
-lean_dec(x_240);
-lean_dec(x_230);
-lean_dec(x_216);
+lean_dec(x_232);
+lean_dec(x_218);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -16758,34 +16762,34 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_1);
-x_272 = lean_ctor_get(x_242, 0);
-lean_inc(x_272);
-x_273 = lean_ctor_get(x_242, 1);
-lean_inc(x_273);
-if (lean_is_exclusive(x_242)) {
- lean_ctor_release(x_242, 0);
- lean_ctor_release(x_242, 1);
- x_274 = x_242;
+x_274 = lean_ctor_get(x_244, 0);
+lean_inc(x_274);
+x_275 = lean_ctor_get(x_244, 1);
+lean_inc(x_275);
+if (lean_is_exclusive(x_244)) {
+ lean_ctor_release(x_244, 0);
+ lean_ctor_release(x_244, 1);
+ x_276 = x_244;
 } else {
- lean_dec_ref(x_242);
- x_274 = lean_box(0);
+ lean_dec_ref(x_244);
+ x_276 = lean_box(0);
 }
-if (lean_is_scalar(x_274)) {
- x_275 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_276)) {
+ x_277 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_275 = x_274;
+ x_277 = x_276;
 }
-lean_ctor_set(x_275, 0, x_272);
-lean_ctor_set(x_275, 1, x_273);
-return x_275;
+lean_ctor_set(x_277, 0, x_274);
+lean_ctor_set(x_277, 1, x_275);
+return x_277;
 }
 }
 else
 {
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; 
-lean_dec(x_230);
-lean_dec(x_220);
-lean_dec(x_216);
+lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; 
+lean_dec(x_232);
+lean_dec(x_222);
+lean_dec(x_218);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -16793,33 +16797,33 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_1);
-x_276 = lean_ctor_get(x_239, 0);
-lean_inc(x_276);
-x_277 = lean_ctor_get(x_239, 1);
-lean_inc(x_277);
-if (lean_is_exclusive(x_239)) {
- lean_ctor_release(x_239, 0);
- lean_ctor_release(x_239, 1);
- x_278 = x_239;
+x_278 = lean_ctor_get(x_241, 0);
+lean_inc(x_278);
+x_279 = lean_ctor_get(x_241, 1);
+lean_inc(x_279);
+if (lean_is_exclusive(x_241)) {
+ lean_ctor_release(x_241, 0);
+ lean_ctor_release(x_241, 1);
+ x_280 = x_241;
 } else {
- lean_dec_ref(x_239);
- x_278 = lean_box(0);
+ lean_dec_ref(x_241);
+ x_280 = lean_box(0);
 }
-if (lean_is_scalar(x_278)) {
- x_279 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_280)) {
+ x_281 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_279 = x_278;
+ x_281 = x_280;
 }
-lean_ctor_set(x_279, 0, x_276);
-lean_ctor_set(x_279, 1, x_277);
-return x_279;
+lean_ctor_set(x_281, 0, x_278);
+lean_ctor_set(x_281, 1, x_279);
+return x_281;
 }
 }
 else
 {
-lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; 
-lean_dec(x_220);
-lean_dec(x_216);
+lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; 
+lean_dec(x_222);
+lean_dec(x_218);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -16828,32 +16832,32 @@ lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_280 = lean_ctor_get(x_229, 0);
-lean_inc(x_280);
-x_281 = lean_ctor_get(x_229, 1);
-lean_inc(x_281);
-if (lean_is_exclusive(x_229)) {
- lean_ctor_release(x_229, 0);
- lean_ctor_release(x_229, 1);
- x_282 = x_229;
+x_282 = lean_ctor_get(x_231, 0);
+lean_inc(x_282);
+x_283 = lean_ctor_get(x_231, 1);
+lean_inc(x_283);
+if (lean_is_exclusive(x_231)) {
+ lean_ctor_release(x_231, 0);
+ lean_ctor_release(x_231, 1);
+ x_284 = x_231;
 } else {
- lean_dec_ref(x_229);
- x_282 = lean_box(0);
+ lean_dec_ref(x_231);
+ x_284 = lean_box(0);
 }
-if (lean_is_scalar(x_282)) {
- x_283 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_284)) {
+ x_285 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_283 = x_282;
+ x_285 = x_284;
 }
-lean_ctor_set(x_283, 0, x_280);
-lean_ctor_set(x_283, 1, x_281);
-return x_283;
+lean_ctor_set(x_285, 0, x_282);
+lean_ctor_set(x_285, 1, x_283);
+return x_285;
 }
 }
 else
 {
-lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; 
-lean_dec(x_216);
+lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; 
+lean_dec(x_218);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -16863,63 +16867,63 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_284 = lean_ctor_get(x_219, 0);
-lean_inc(x_284);
-x_285 = lean_ctor_get(x_219, 1);
-lean_inc(x_285);
+x_286 = lean_ctor_get(x_221, 0);
+lean_inc(x_286);
+x_287 = lean_ctor_get(x_221, 1);
+lean_inc(x_287);
+if (lean_is_exclusive(x_221)) {
+ lean_ctor_release(x_221, 0);
+ lean_ctor_release(x_221, 1);
+ x_288 = x_221;
+} else {
+ lean_dec_ref(x_221);
+ x_288 = lean_box(0);
+}
+if (lean_is_scalar(x_288)) {
+ x_289 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_289 = x_288;
+}
+lean_ctor_set(x_289, 0, x_286);
+lean_ctor_set(x_289, 1, x_287);
+return x_289;
+}
+}
+else
+{
+lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
+lean_dec(x_218);
+lean_dec(x_34);
+lean_dec(x_11);
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_7);
+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_290 = lean_ctor_get(x_219, 0);
+lean_inc(x_290);
+x_291 = lean_ctor_get(x_219, 1);
+lean_inc(x_291);
 if (lean_is_exclusive(x_219)) {
  lean_ctor_release(x_219, 0);
  lean_ctor_release(x_219, 1);
- x_286 = x_219;
+ x_292 = x_219;
 } else {
  lean_dec_ref(x_219);
- x_286 = lean_box(0);
+ x_292 = lean_box(0);
 }
-if (lean_is_scalar(x_286)) {
- x_287 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_292)) {
+ x_293 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_287 = x_286;
+ x_293 = x_292;
 }
-lean_ctor_set(x_287, 0, x_284);
-lean_ctor_set(x_287, 1, x_285);
-return x_287;
-}
-}
-else
-{
-lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; 
-lean_dec(x_216);
-lean_dec(x_34);
-lean_dec(x_11);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_7);
-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_288 = lean_ctor_get(x_217, 0);
-lean_inc(x_288);
-x_289 = lean_ctor_get(x_217, 1);
-lean_inc(x_289);
-if (lean_is_exclusive(x_217)) {
- lean_ctor_release(x_217, 0);
- lean_ctor_release(x_217, 1);
- x_290 = x_217;
-} else {
- lean_dec_ref(x_217);
- x_290 = lean_box(0);
-}
-if (lean_is_scalar(x_290)) {
- x_291 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_291 = x_290;
-}
-lean_ctor_set(x_291, 0, x_288);
-lean_ctor_set(x_291, 1, x_289);
-return x_291;
+lean_ctor_set(x_293, 0, x_290);
+lean_ctor_set(x_293, 1, x_291);
+return x_293;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Main.c b/stage0/stdlib/Lean/Elab/PreDefinition/Main.c
index bcbc71d8a6..e65e9b8feb 100644
--- a/stage0/stdlib/Lean/Elab/PreDefinition/Main.c
+++ b/stage0/stdlib/Lean/Elab/PreDefinition/Main.c
@@ -59,7 +59,6 @@ lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompile
 lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__20(lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_ensureNoUnassignedMVarsAtPreDef(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__1___lambda__1___closed__2;
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addAndCompileUnsafe(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -189,6 +188,7 @@ lean_object* l_Std_AssocList_find_x3f___at___private_Lean_Elab_PreDefinition_Mai
 lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__17(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_findSomeM_x3f___rarg___closed__1;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__1___closed__1;
+uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_Structural_elimRecursion___lambda__2___closed__3;
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__1___lambda__2___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -2065,7 +2065,7 @@ lean_inc(x_24);
 x_25 = lean_ctor_get(x_22, 0);
 lean_inc(x_25);
 lean_dec(x_22);
-x_26 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(x_24, x_25);
+x_26 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(x_24, x_25);
 lean_dec(x_25);
 lean_dec(x_24);
 if (x_26 == 0)
@@ -2098,7 +2098,7 @@ lean_inc(x_31);
 x_32 = lean_ctor_get(x_29, 0);
 lean_inc(x_32);
 lean_dec(x_29);
-x_33 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(x_31, x_32);
+x_33 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(x_31, x_32);
 lean_dec(x_32);
 lean_dec(x_31);
 if (x_33 == 0)
diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/MkInhabitant.c b/stage0/stdlib/Lean/Elab/PreDefinition/MkInhabitant.c
index 64a2a0b5f6..171af96d9a 100644
--- a/stage0/stdlib/Lean/Elab/PreDefinition/MkInhabitant.c
+++ b/stage0/stdlib/Lean/Elab/PreDefinition/MkInhabitant.c
@@ -20,7 +20,6 @@ lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l___private_Lean_Elab_PreDefinition_MkInhabitant_0__Lean_Elab_mkFnInhabitant_x3f_loop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_MkInhabitant_0__Lean_Elab_mkFnInhabitant_x3f_loop_match__1(lean_object*);
 lean_object* l_Lean_Elab_mkInhabitantFor___closed__4;
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_MkInhabitant_0__Lean_Elab_findAssumption_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toSubarray___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
@@ -29,6 +28,7 @@ lean_object* l___private_Lean_Elab_PreDefinition_MkInhabitant_0__Lean_Elab_mkFnI
 lean_object* l_Lean_Elab_mkInhabitantFor___closed__1;
 lean_object* l_Lean_Elab_mkInhabitantFor_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_mkInhabitantFor___closed__2;
 lean_object* l___private_Lean_Elab_PreDefinition_MkInhabitant_0__Lean_Elab_mkInhabitant_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_mkInhabitantFor(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -865,7 +865,7 @@ x_21 = l_Lean_Elab_mkInhabitantFor___closed__4;
 x_22 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_22, 0, x_20);
 lean_ctor_set(x_22, 1, x_21);
-x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_22, x_4, x_5, x_6, x_7, x_17);
+x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_22, x_4, x_5, x_6, x_7, x_17);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c b/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c
index b756e1b6b2..74654f4cab 100644
--- a/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c
+++ b/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c
@@ -376,7 +376,7 @@ lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Str
 lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Meta_addPPExplicitToExposeDiff_visit___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Structural_addSmartUnfoldingDefAux_visit___spec__5___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_Structural_hasBadIndexDep_x3f_match__1(lean_object*);
-lean_object* l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural___hyg_5133_(lean_object*);
+lean_object* l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural___hyg_5135_(lean_object*);
 lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_Structural_hasBadParamDep_x3f___spec__2(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_ofSubarray___rarg(lean_object*);
@@ -659,722 +659,732 @@ x_26 = lean_ctor_get(x_4, 0);
 x_27 = !lean_is_exclusive(x_26);
 if (x_27 == 0)
 {
-uint8_t x_28; lean_object* x_29; 
+uint8_t x_28; uint8_t x_29; lean_object* x_30; 
 x_28 = 2;
+x_29 = 0;
 lean_ctor_set_uint8(x_26, 5, x_28);
-x_29 = l_Lean_Meta_isExprDefEq(x_3, x_22, x_4, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_29) == 0)
+lean_ctor_set_uint8(x_26, 9, x_29);
+x_30 = l_Lean_Meta_isExprDefEq(x_3, x_22, x_4, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_30; uint8_t x_31; 
-x_30 = lean_ctor_get(x_29, 0);
-lean_inc(x_30);
-x_31 = lean_unbox(x_30);
-lean_dec(x_30);
-if (x_31 == 0)
-{
-uint8_t x_32; 
-lean_dec(x_2);
-x_32 = !lean_is_exclusive(x_29);
+lean_object* x_31; uint8_t x_32; 
+x_31 = lean_ctor_get(x_30, 0);
+lean_inc(x_31);
+x_32 = lean_unbox(x_31);
+lean_dec(x_31);
 if (x_32 == 0)
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_33 = lean_ctor_get(x_29, 0);
-lean_dec(x_33);
-x_34 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
-lean_ctor_set(x_1, 0, x_34);
-x_35 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_35, 0, x_1);
-lean_ctor_set(x_29, 0, x_35);
-return x_29;
+uint8_t x_33; 
+lean_dec(x_2);
+x_33 = !lean_is_exclusive(x_30);
+if (x_33 == 0)
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_34 = lean_ctor_get(x_30, 0);
+lean_dec(x_34);
+x_35 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
+lean_ctor_set(x_1, 0, x_35);
+x_36 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_36, 0, x_1);
+lean_ctor_set(x_30, 0, x_36);
+return x_30;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_36 = lean_ctor_get(x_29, 1);
-lean_inc(x_36);
-lean_dec(x_29);
-x_37 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
-lean_ctor_set(x_1, 0, x_37);
-x_38 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_38, 0, x_1);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_36);
-return x_39;
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_37 = lean_ctor_get(x_30, 1);
+lean_inc(x_37);
+lean_dec(x_30);
+x_38 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
+lean_ctor_set(x_1, 0, x_38);
+x_39 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_39, 0, x_1);
+x_40 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_40, 0, x_39);
+lean_ctor_set(x_40, 1, x_37);
+return x_40;
 }
 }
 else
 {
-uint8_t x_40; 
-x_40 = !lean_is_exclusive(x_29);
-if (x_40 == 0)
+uint8_t x_41; 
+x_41 = !lean_is_exclusive(x_30);
+if (x_41 == 0)
 {
-lean_object* x_41; lean_object* x_42; 
-x_41 = lean_ctor_get(x_29, 0);
-lean_dec(x_41);
+lean_object* x_42; lean_object* x_43; 
+x_42 = lean_ctor_get(x_30, 0);
+lean_dec(x_42);
 lean_ctor_set(x_1, 0, x_2);
-x_42 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_42, 0, x_1);
-lean_ctor_set(x_29, 0, x_42);
-return x_29;
+x_43 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_43, 0, x_1);
+lean_ctor_set(x_30, 0, x_43);
+return x_30;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_29, 1);
-lean_inc(x_43);
-lean_dec(x_29);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_44 = lean_ctor_get(x_30, 1);
+lean_inc(x_44);
+lean_dec(x_30);
 lean_ctor_set(x_1, 0, x_2);
-x_44 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_44, 0, x_1);
-x_45 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_45, 0, x_44);
-lean_ctor_set(x_45, 1, x_43);
-return x_45;
+x_45 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_45, 0, x_1);
+x_46 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_46, 0, x_45);
+lean_ctor_set(x_46, 1, x_44);
+return x_46;
 }
 }
 }
 else
 {
-uint8_t x_46; 
+uint8_t x_47; 
 lean_dec(x_10);
 lean_free_object(x_1);
 lean_dec(x_2);
-x_46 = !lean_is_exclusive(x_29);
-if (x_46 == 0)
+x_47 = !lean_is_exclusive(x_30);
+if (x_47 == 0)
 {
-return x_29;
+return x_30;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_47 = lean_ctor_get(x_29, 0);
-x_48 = lean_ctor_get(x_29, 1);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_48 = lean_ctor_get(x_30, 0);
+x_49 = lean_ctor_get(x_30, 1);
+lean_inc(x_49);
 lean_inc(x_48);
-lean_inc(x_47);
-lean_dec(x_29);
-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_dec(x_30);
+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;
 }
 }
 }
 else
 {
-uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; 
-x_50 = lean_ctor_get_uint8(x_26, 0);
-x_51 = lean_ctor_get_uint8(x_26, 1);
-x_52 = lean_ctor_get_uint8(x_26, 2);
-x_53 = lean_ctor_get_uint8(x_26, 3);
-x_54 = lean_ctor_get_uint8(x_26, 4);
-x_55 = lean_ctor_get_uint8(x_26, 6);
-x_56 = lean_ctor_get_uint8(x_26, 7);
-x_57 = lean_ctor_get_uint8(x_26, 8);
+uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; uint8_t x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; 
+x_51 = lean_ctor_get_uint8(x_26, 0);
+x_52 = lean_ctor_get_uint8(x_26, 1);
+x_53 = lean_ctor_get_uint8(x_26, 2);
+x_54 = lean_ctor_get_uint8(x_26, 3);
+x_55 = lean_ctor_get_uint8(x_26, 4);
+x_56 = lean_ctor_get_uint8(x_26, 6);
+x_57 = lean_ctor_get_uint8(x_26, 7);
+x_58 = lean_ctor_get_uint8(x_26, 8);
 lean_dec(x_26);
-x_58 = 2;
-x_59 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_59, 0, x_50);
-lean_ctor_set_uint8(x_59, 1, x_51);
-lean_ctor_set_uint8(x_59, 2, x_52);
-lean_ctor_set_uint8(x_59, 3, x_53);
-lean_ctor_set_uint8(x_59, 4, x_54);
-lean_ctor_set_uint8(x_59, 5, x_58);
-lean_ctor_set_uint8(x_59, 6, x_55);
-lean_ctor_set_uint8(x_59, 7, x_56);
-lean_ctor_set_uint8(x_59, 8, x_57);
-lean_ctor_set(x_4, 0, x_59);
-x_60 = l_Lean_Meta_isExprDefEq(x_3, x_22, x_4, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_60) == 0)
+x_59 = 2;
+x_60 = 0;
+x_61 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_61, 0, x_51);
+lean_ctor_set_uint8(x_61, 1, x_52);
+lean_ctor_set_uint8(x_61, 2, x_53);
+lean_ctor_set_uint8(x_61, 3, x_54);
+lean_ctor_set_uint8(x_61, 4, x_55);
+lean_ctor_set_uint8(x_61, 5, x_59);
+lean_ctor_set_uint8(x_61, 6, x_56);
+lean_ctor_set_uint8(x_61, 7, x_57);
+lean_ctor_set_uint8(x_61, 8, x_58);
+lean_ctor_set_uint8(x_61, 9, x_60);
+lean_ctor_set(x_4, 0, x_61);
+x_62 = l_Lean_Meta_isExprDefEq(x_3, x_22, x_4, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_62) == 0)
 {
-lean_object* x_61; uint8_t x_62; 
-x_61 = lean_ctor_get(x_60, 0);
-lean_inc(x_61);
-x_62 = lean_unbox(x_61);
-lean_dec(x_61);
-if (x_62 == 0)
-{
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-lean_dec(x_2);
-x_63 = lean_ctor_get(x_60, 1);
+lean_object* x_63; uint8_t x_64; 
+x_63 = lean_ctor_get(x_62, 0);
 lean_inc(x_63);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- lean_ctor_release(x_60, 1);
- x_64 = x_60;
+x_64 = lean_unbox(x_63);
+lean_dec(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_dec(x_2);
+x_65 = lean_ctor_get(x_62, 1);
+lean_inc(x_65);
+if (lean_is_exclusive(x_62)) {
+ lean_ctor_release(x_62, 0);
+ lean_ctor_release(x_62, 1);
+ x_66 = x_62;
 } else {
- lean_dec_ref(x_60);
- x_64 = lean_box(0);
+ lean_dec_ref(x_62);
+ x_66 = lean_box(0);
 }
-x_65 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
-lean_ctor_set(x_1, 0, x_65);
-x_66 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_66, 0, x_1);
-if (lean_is_scalar(x_64)) {
- x_67 = lean_alloc_ctor(0, 2, 0);
+x_67 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
+lean_ctor_set(x_1, 0, x_67);
+x_68 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_68, 0, x_1);
+if (lean_is_scalar(x_66)) {
+ x_69 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_67 = x_64;
+ x_69 = x_66;
 }
-lean_ctor_set(x_67, 0, x_66);
-lean_ctor_set(x_67, 1, x_63);
-return x_67;
+lean_ctor_set(x_69, 0, x_68);
+lean_ctor_set(x_69, 1, x_65);
+return x_69;
 }
 else
 {
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-x_68 = lean_ctor_get(x_60, 1);
-lean_inc(x_68);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- lean_ctor_release(x_60, 1);
- x_69 = x_60;
+lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+x_70 = lean_ctor_get(x_62, 1);
+lean_inc(x_70);
+if (lean_is_exclusive(x_62)) {
+ lean_ctor_release(x_62, 0);
+ lean_ctor_release(x_62, 1);
+ x_71 = x_62;
 } else {
- lean_dec_ref(x_60);
- x_69 = lean_box(0);
+ lean_dec_ref(x_62);
+ x_71 = lean_box(0);
 }
 lean_ctor_set(x_1, 0, x_2);
-x_70 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_70, 0, x_1);
-if (lean_is_scalar(x_69)) {
- x_71 = lean_alloc_ctor(0, 2, 0);
+x_72 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_72, 0, x_1);
+if (lean_is_scalar(x_71)) {
+ x_73 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_71 = x_69;
+ x_73 = x_71;
 }
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_71, 1, x_68);
-return x_71;
+lean_ctor_set(x_73, 0, x_72);
+lean_ctor_set(x_73, 1, x_70);
+return x_73;
 }
 }
 else
 {
-lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
+lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
 lean_dec(x_10);
 lean_free_object(x_1);
 lean_dec(x_2);
-x_72 = lean_ctor_get(x_60, 0);
-lean_inc(x_72);
-x_73 = lean_ctor_get(x_60, 1);
-lean_inc(x_73);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- lean_ctor_release(x_60, 1);
- x_74 = x_60;
+x_74 = lean_ctor_get(x_62, 0);
+lean_inc(x_74);
+x_75 = lean_ctor_get(x_62, 1);
+lean_inc(x_75);
+if (lean_is_exclusive(x_62)) {
+ lean_ctor_release(x_62, 0);
+ lean_ctor_release(x_62, 1);
+ x_76 = x_62;
 } else {
- lean_dec_ref(x_60);
- x_74 = lean_box(0);
+ lean_dec_ref(x_62);
+ x_76 = lean_box(0);
 }
-if (lean_is_scalar(x_74)) {
- x_75 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_76)) {
+ x_77 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_75 = x_74;
+ x_77 = x_76;
 }
-lean_ctor_set(x_75, 0, x_72);
-lean_ctor_set(x_75, 1, x_73);
-return x_75;
+lean_ctor_set(x_77, 0, x_74);
+lean_ctor_set(x_77, 1, x_75);
+return x_77;
 }
 }
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; lean_object* x_88; uint8_t x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-x_76 = lean_ctor_get(x_4, 0);
-x_77 = lean_ctor_get(x_4, 1);
-x_78 = lean_ctor_get(x_4, 2);
-x_79 = lean_ctor_get(x_4, 3);
+lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; uint8_t x_88; uint8_t x_89; lean_object* x_90; uint8_t x_91; uint8_t x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+x_78 = lean_ctor_get(x_4, 0);
+x_79 = lean_ctor_get(x_4, 1);
+x_80 = lean_ctor_get(x_4, 2);
+x_81 = lean_ctor_get(x_4, 3);
+lean_inc(x_81);
+lean_inc(x_80);
 lean_inc(x_79);
 lean_inc(x_78);
-lean_inc(x_77);
-lean_inc(x_76);
 lean_dec(x_4);
-x_80 = lean_ctor_get_uint8(x_76, 0);
-x_81 = lean_ctor_get_uint8(x_76, 1);
-x_82 = lean_ctor_get_uint8(x_76, 2);
-x_83 = lean_ctor_get_uint8(x_76, 3);
-x_84 = lean_ctor_get_uint8(x_76, 4);
-x_85 = lean_ctor_get_uint8(x_76, 6);
-x_86 = lean_ctor_get_uint8(x_76, 7);
-x_87 = lean_ctor_get_uint8(x_76, 8);
-if (lean_is_exclusive(x_76)) {
- x_88 = x_76;
+x_82 = lean_ctor_get_uint8(x_78, 0);
+x_83 = lean_ctor_get_uint8(x_78, 1);
+x_84 = lean_ctor_get_uint8(x_78, 2);
+x_85 = lean_ctor_get_uint8(x_78, 3);
+x_86 = lean_ctor_get_uint8(x_78, 4);
+x_87 = lean_ctor_get_uint8(x_78, 6);
+x_88 = lean_ctor_get_uint8(x_78, 7);
+x_89 = lean_ctor_get_uint8(x_78, 8);
+if (lean_is_exclusive(x_78)) {
+ x_90 = x_78;
 } else {
- lean_dec_ref(x_76);
- x_88 = lean_box(0);
+ lean_dec_ref(x_78);
+ x_90 = lean_box(0);
 }
-x_89 = 2;
-if (lean_is_scalar(x_88)) {
- x_90 = lean_alloc_ctor(0, 0, 9);
+x_91 = 2;
+x_92 = 0;
+if (lean_is_scalar(x_90)) {
+ x_93 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_90 = x_88;
+ x_93 = x_90;
 }
-lean_ctor_set_uint8(x_90, 0, x_80);
-lean_ctor_set_uint8(x_90, 1, x_81);
-lean_ctor_set_uint8(x_90, 2, x_82);
-lean_ctor_set_uint8(x_90, 3, x_83);
-lean_ctor_set_uint8(x_90, 4, x_84);
-lean_ctor_set_uint8(x_90, 5, x_89);
-lean_ctor_set_uint8(x_90, 6, x_85);
-lean_ctor_set_uint8(x_90, 7, x_86);
-lean_ctor_set_uint8(x_90, 8, x_87);
-x_91 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_77);
-lean_ctor_set(x_91, 2, x_78);
-lean_ctor_set(x_91, 3, x_79);
-x_92 = l_Lean_Meta_isExprDefEq(x_3, x_22, x_91, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_92) == 0)
+lean_ctor_set_uint8(x_93, 0, x_82);
+lean_ctor_set_uint8(x_93, 1, x_83);
+lean_ctor_set_uint8(x_93, 2, x_84);
+lean_ctor_set_uint8(x_93, 3, x_85);
+lean_ctor_set_uint8(x_93, 4, x_86);
+lean_ctor_set_uint8(x_93, 5, x_91);
+lean_ctor_set_uint8(x_93, 6, x_87);
+lean_ctor_set_uint8(x_93, 7, x_88);
+lean_ctor_set_uint8(x_93, 8, x_89);
+lean_ctor_set_uint8(x_93, 9, x_92);
+x_94 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_94, 0, x_93);
+lean_ctor_set(x_94, 1, x_79);
+lean_ctor_set(x_94, 2, x_80);
+lean_ctor_set(x_94, 3, x_81);
+x_95 = l_Lean_Meta_isExprDefEq(x_3, x_22, x_94, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_95) == 0)
 {
-lean_object* x_93; uint8_t x_94; 
-x_93 = lean_ctor_get(x_92, 0);
-lean_inc(x_93);
-x_94 = lean_unbox(x_93);
-lean_dec(x_93);
-if (x_94 == 0)
+lean_object* x_96; uint8_t x_97; 
+x_96 = lean_ctor_get(x_95, 0);
+lean_inc(x_96);
+x_97 = lean_unbox(x_96);
+lean_dec(x_96);
+if (x_97 == 0)
 {
-lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
 lean_dec(x_2);
-x_95 = lean_ctor_get(x_92, 1);
-lean_inc(x_95);
-if (lean_is_exclusive(x_92)) {
- lean_ctor_release(x_92, 0);
- lean_ctor_release(x_92, 1);
- x_96 = x_92;
+x_98 = lean_ctor_get(x_95, 1);
+lean_inc(x_98);
+if (lean_is_exclusive(x_95)) {
+ lean_ctor_release(x_95, 0);
+ lean_ctor_release(x_95, 1);
+ x_99 = x_95;
 } else {
- lean_dec_ref(x_92);
- x_96 = lean_box(0);
+ lean_dec_ref(x_95);
+ x_99 = lean_box(0);
 }
-x_97 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
-lean_ctor_set(x_1, 0, x_97);
-x_98 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_98, 0, x_1);
-if (lean_is_scalar(x_96)) {
- x_99 = lean_alloc_ctor(0, 2, 0);
+x_100 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
+lean_ctor_set(x_1, 0, x_100);
+x_101 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_101, 0, x_1);
+if (lean_is_scalar(x_99)) {
+ x_102 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_99 = x_96;
+ x_102 = x_99;
 }
-lean_ctor_set(x_99, 0, x_98);
-lean_ctor_set(x_99, 1, x_95);
-return x_99;
+lean_ctor_set(x_102, 0, x_101);
+lean_ctor_set(x_102, 1, x_98);
+return x_102;
 }
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-x_100 = lean_ctor_get(x_92, 1);
-lean_inc(x_100);
-if (lean_is_exclusive(x_92)) {
- lean_ctor_release(x_92, 0);
- lean_ctor_release(x_92, 1);
- x_101 = x_92;
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; 
+x_103 = lean_ctor_get(x_95, 1);
+lean_inc(x_103);
+if (lean_is_exclusive(x_95)) {
+ lean_ctor_release(x_95, 0);
+ lean_ctor_release(x_95, 1);
+ x_104 = x_95;
 } else {
- lean_dec_ref(x_92);
- x_101 = lean_box(0);
+ lean_dec_ref(x_95);
+ x_104 = lean_box(0);
 }
 lean_ctor_set(x_1, 0, x_2);
-x_102 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_102, 0, x_1);
-if (lean_is_scalar(x_101)) {
- x_103 = lean_alloc_ctor(0, 2, 0);
+x_105 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_105, 0, x_1);
+if (lean_is_scalar(x_104)) {
+ x_106 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_103 = x_101;
+ x_106 = x_104;
 }
-lean_ctor_set(x_103, 0, x_102);
-lean_ctor_set(x_103, 1, x_100);
-return x_103;
+lean_ctor_set(x_106, 0, x_105);
+lean_ctor_set(x_106, 1, x_103);
+return x_106;
 }
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; 
+lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; 
 lean_dec(x_10);
 lean_free_object(x_1);
 lean_dec(x_2);
-x_104 = lean_ctor_get(x_92, 0);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_92, 1);
-lean_inc(x_105);
-if (lean_is_exclusive(x_92)) {
- lean_ctor_release(x_92, 0);
- lean_ctor_release(x_92, 1);
- x_106 = x_92;
+x_107 = lean_ctor_get(x_95, 0);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_95, 1);
+lean_inc(x_108);
+if (lean_is_exclusive(x_95)) {
+ lean_ctor_release(x_95, 0);
+ lean_ctor_release(x_95, 1);
+ x_109 = x_95;
 } else {
- lean_dec_ref(x_92);
- x_106 = lean_box(0);
+ lean_dec_ref(x_95);
+ x_109 = lean_box(0);
 }
-if (lean_is_scalar(x_106)) {
- x_107 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_109)) {
+ x_110 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_107 = x_106;
+ x_110 = x_109;
 }
-lean_ctor_set(x_107, 0, x_104);
-lean_ctor_set(x_107, 1, x_105);
-return x_107;
+lean_ctor_set(x_110, 0, x_107);
+lean_ctor_set(x_110, 1, x_108);
+return x_110;
 }
 }
 }
 else
 {
-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; uint8_t x_117; uint8_t x_118; uint8_t x_119; uint8_t x_120; uint8_t x_121; uint8_t x_122; uint8_t x_123; uint8_t x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; 
+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; uint8_t x_120; uint8_t x_121; uint8_t x_122; uint8_t x_123; uint8_t x_124; uint8_t x_125; uint8_t x_126; uint8_t x_127; lean_object* x_128; uint8_t x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
 lean_dec(x_10);
-x_108 = lean_array_fget(x_12, x_13);
-x_109 = lean_unsigned_to_nat(1u);
-x_110 = lean_nat_add(x_13, x_109);
+x_111 = lean_array_fget(x_12, x_13);
+x_112 = lean_unsigned_to_nat(1u);
+x_113 = lean_nat_add(x_13, x_112);
 lean_dec(x_13);
-x_111 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_111, 0, x_12);
-lean_ctor_set(x_111, 1, x_110);
-lean_ctor_set(x_111, 2, x_14);
-x_112 = lean_ctor_get(x_4, 0);
-lean_inc(x_112);
-x_113 = lean_ctor_get(x_4, 1);
-lean_inc(x_113);
-x_114 = lean_ctor_get(x_4, 2);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_4, 3);
+x_114 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_114, 0, x_12);
+lean_ctor_set(x_114, 1, x_113);
+lean_ctor_set(x_114, 2, x_14);
+x_115 = lean_ctor_get(x_4, 0);
 lean_inc(x_115);
+x_116 = lean_ctor_get(x_4, 1);
+lean_inc(x_116);
+x_117 = lean_ctor_get(x_4, 2);
+lean_inc(x_117);
+x_118 = lean_ctor_get(x_4, 3);
+lean_inc(x_118);
 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);
- x_116 = x_4;
+ x_119 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_116 = lean_box(0);
+ x_119 = lean_box(0);
 }
-x_117 = lean_ctor_get_uint8(x_112, 0);
-x_118 = lean_ctor_get_uint8(x_112, 1);
-x_119 = lean_ctor_get_uint8(x_112, 2);
-x_120 = lean_ctor_get_uint8(x_112, 3);
-x_121 = lean_ctor_get_uint8(x_112, 4);
-x_122 = lean_ctor_get_uint8(x_112, 6);
-x_123 = lean_ctor_get_uint8(x_112, 7);
-x_124 = lean_ctor_get_uint8(x_112, 8);
-if (lean_is_exclusive(x_112)) {
- x_125 = x_112;
+x_120 = lean_ctor_get_uint8(x_115, 0);
+x_121 = lean_ctor_get_uint8(x_115, 1);
+x_122 = lean_ctor_get_uint8(x_115, 2);
+x_123 = lean_ctor_get_uint8(x_115, 3);
+x_124 = lean_ctor_get_uint8(x_115, 4);
+x_125 = lean_ctor_get_uint8(x_115, 6);
+x_126 = lean_ctor_get_uint8(x_115, 7);
+x_127 = lean_ctor_get_uint8(x_115, 8);
+if (lean_is_exclusive(x_115)) {
+ x_128 = x_115;
 } else {
- lean_dec_ref(x_112);
- x_125 = lean_box(0);
+ lean_dec_ref(x_115);
+ x_128 = lean_box(0);
 }
-x_126 = 2;
-if (lean_is_scalar(x_125)) {
- x_127 = lean_alloc_ctor(0, 0, 9);
+x_129 = 2;
+x_130 = 0;
+if (lean_is_scalar(x_128)) {
+ x_131 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_127 = x_125;
+ x_131 = x_128;
 }
-lean_ctor_set_uint8(x_127, 0, x_117);
-lean_ctor_set_uint8(x_127, 1, x_118);
-lean_ctor_set_uint8(x_127, 2, x_119);
-lean_ctor_set_uint8(x_127, 3, x_120);
-lean_ctor_set_uint8(x_127, 4, x_121);
-lean_ctor_set_uint8(x_127, 5, x_126);
-lean_ctor_set_uint8(x_127, 6, x_122);
-lean_ctor_set_uint8(x_127, 7, x_123);
-lean_ctor_set_uint8(x_127, 8, x_124);
-if (lean_is_scalar(x_116)) {
- x_128 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set_uint8(x_131, 0, x_120);
+lean_ctor_set_uint8(x_131, 1, x_121);
+lean_ctor_set_uint8(x_131, 2, x_122);
+lean_ctor_set_uint8(x_131, 3, x_123);
+lean_ctor_set_uint8(x_131, 4, x_124);
+lean_ctor_set_uint8(x_131, 5, x_129);
+lean_ctor_set_uint8(x_131, 6, x_125);
+lean_ctor_set_uint8(x_131, 7, x_126);
+lean_ctor_set_uint8(x_131, 8, x_127);
+lean_ctor_set_uint8(x_131, 9, x_130);
+if (lean_is_scalar(x_119)) {
+ x_132 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_128 = x_116;
+ x_132 = x_119;
 }
-lean_ctor_set(x_128, 0, x_127);
-lean_ctor_set(x_128, 1, x_113);
-lean_ctor_set(x_128, 2, x_114);
-lean_ctor_set(x_128, 3, x_115);
-x_129 = l_Lean_Meta_isExprDefEq(x_3, x_108, x_128, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_129) == 0)
+lean_ctor_set(x_132, 0, x_131);
+lean_ctor_set(x_132, 1, x_116);
+lean_ctor_set(x_132, 2, x_117);
+lean_ctor_set(x_132, 3, x_118);
+x_133 = l_Lean_Meta_isExprDefEq(x_3, x_111, x_132, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_133) == 0)
 {
-lean_object* x_130; uint8_t x_131; 
-x_130 = lean_ctor_get(x_129, 0);
-lean_inc(x_130);
-x_131 = lean_unbox(x_130);
-lean_dec(x_130);
-if (x_131 == 0)
+lean_object* x_134; uint8_t x_135; 
+x_134 = lean_ctor_get(x_133, 0);
+lean_inc(x_134);
+x_135 = lean_unbox(x_134);
+lean_dec(x_134);
+if (x_135 == 0)
 {
-lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
+lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
 lean_dec(x_2);
-x_132 = lean_ctor_get(x_129, 1);
-lean_inc(x_132);
-if (lean_is_exclusive(x_129)) {
- lean_ctor_release(x_129, 0);
- lean_ctor_release(x_129, 1);
- x_133 = x_129;
+x_136 = lean_ctor_get(x_133, 1);
+lean_inc(x_136);
+if (lean_is_exclusive(x_133)) {
+ lean_ctor_release(x_133, 0);
+ lean_ctor_release(x_133, 1);
+ x_137 = x_133;
 } else {
- lean_dec_ref(x_129);
- x_133 = lean_box(0);
+ lean_dec_ref(x_133);
+ x_137 = lean_box(0);
 }
-x_134 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
-lean_ctor_set(x_1, 1, x_111);
-lean_ctor_set(x_1, 0, x_134);
-x_135 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_135, 0, x_1);
-if (lean_is_scalar(x_133)) {
- x_136 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_136 = x_133;
-}
-lean_ctor_set(x_136, 0, x_135);
-lean_ctor_set(x_136, 1, x_132);
-return x_136;
-}
-else
-{
-lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
-x_137 = lean_ctor_get(x_129, 1);
-lean_inc(x_137);
-if (lean_is_exclusive(x_129)) {
- lean_ctor_release(x_129, 0);
- lean_ctor_release(x_129, 1);
- x_138 = x_129;
-} else {
- lean_dec_ref(x_129);
- x_138 = lean_box(0);
-}
-lean_ctor_set(x_1, 1, x_111);
-lean_ctor_set(x_1, 0, x_2);
-x_139 = lean_alloc_ctor(1, 1, 0);
+x_138 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
+lean_ctor_set(x_1, 1, x_114);
+lean_ctor_set(x_1, 0, x_138);
+x_139 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_139, 0, x_1);
-if (lean_is_scalar(x_138)) {
+if (lean_is_scalar(x_137)) {
  x_140 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_140 = x_138;
+ x_140 = x_137;
 }
 lean_ctor_set(x_140, 0, x_139);
-lean_ctor_set(x_140, 1, x_137);
+lean_ctor_set(x_140, 1, x_136);
 return x_140;
 }
-}
 else
 {
 lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; 
-lean_dec(x_111);
+x_141 = lean_ctor_get(x_133, 1);
+lean_inc(x_141);
+if (lean_is_exclusive(x_133)) {
+ lean_ctor_release(x_133, 0);
+ lean_ctor_release(x_133, 1);
+ x_142 = x_133;
+} else {
+ lean_dec_ref(x_133);
+ x_142 = lean_box(0);
+}
+lean_ctor_set(x_1, 1, x_114);
+lean_ctor_set(x_1, 0, x_2);
+x_143 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_143, 0, x_1);
+if (lean_is_scalar(x_142)) {
+ x_144 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_144 = x_142;
+}
+lean_ctor_set(x_144, 0, x_143);
+lean_ctor_set(x_144, 1, x_141);
+return x_144;
+}
+}
+else
+{
+lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; 
+lean_dec(x_114);
 lean_free_object(x_1);
 lean_dec(x_2);
-x_141 = lean_ctor_get(x_129, 0);
-lean_inc(x_141);
-x_142 = lean_ctor_get(x_129, 1);
-lean_inc(x_142);
-if (lean_is_exclusive(x_129)) {
- lean_ctor_release(x_129, 0);
- lean_ctor_release(x_129, 1);
- x_143 = x_129;
+x_145 = lean_ctor_get(x_133, 0);
+lean_inc(x_145);
+x_146 = lean_ctor_get(x_133, 1);
+lean_inc(x_146);
+if (lean_is_exclusive(x_133)) {
+ lean_ctor_release(x_133, 0);
+ lean_ctor_release(x_133, 1);
+ x_147 = x_133;
 } else {
- lean_dec_ref(x_129);
- x_143 = lean_box(0);
+ lean_dec_ref(x_133);
+ x_147 = lean_box(0);
 }
-if (lean_is_scalar(x_143)) {
- x_144 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_147)) {
+ x_148 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_144 = x_143;
+ x_148 = x_147;
 }
-lean_ctor_set(x_144, 0, x_141);
-lean_ctor_set(x_144, 1, x_142);
-return x_144;
+lean_ctor_set(x_148, 0, x_145);
+lean_ctor_set(x_148, 1, x_146);
+return x_148;
 }
 }
 }
 }
 else
 {
-lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; uint8_t x_149; 
-x_145 = lean_ctor_get(x_1, 1);
-lean_inc(x_145);
+lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; uint8_t x_153; 
+x_149 = lean_ctor_get(x_1, 1);
+lean_inc(x_149);
 lean_dec(x_1);
-x_146 = lean_ctor_get(x_145, 0);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_145, 1);
-lean_inc(x_147);
-x_148 = lean_ctor_get(x_145, 2);
-lean_inc(x_148);
-x_149 = lean_nat_dec_lt(x_147, x_148);
-if (x_149 == 0)
+x_150 = lean_ctor_get(x_149, 0);
+lean_inc(x_150);
+x_151 = lean_ctor_get(x_149, 1);
+lean_inc(x_151);
+x_152 = lean_ctor_get(x_149, 2);
+lean_inc(x_152);
+x_153 = lean_nat_dec_lt(x_151, x_152);
+if (x_153 == 0)
 {
-lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-lean_dec(x_148);
-lean_dec(x_147);
-lean_dec(x_146);
+lean_object* x_154; lean_object* x_155; lean_object* x_156; 
+lean_dec(x_152);
+lean_dec(x_151);
+lean_dec(x_150);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_150 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_150, 0, x_2);
-lean_ctor_set(x_150, 1, x_145);
-x_151 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_151, 0, x_150);
-x_152 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_152, 0, x_151);
-lean_ctor_set(x_152, 1, x_8);
-return x_152;
+x_154 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_154, 0, x_2);
+lean_ctor_set(x_154, 1, x_149);
+x_155 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_155, 0, x_154);
+x_156 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_156, 0, x_155);
+lean_ctor_set(x_156, 1, x_8);
+return x_156;
 }
 else
 {
-lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; uint8_t x_164; uint8_t x_165; uint8_t x_166; uint8_t x_167; uint8_t x_168; uint8_t x_169; uint8_t x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; 
-if (lean_is_exclusive(x_145)) {
- lean_ctor_release(x_145, 0);
- lean_ctor_release(x_145, 1);
- lean_ctor_release(x_145, 2);
- x_153 = x_145;
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; uint8_t x_167; uint8_t x_168; uint8_t x_169; uint8_t x_170; uint8_t x_171; uint8_t x_172; uint8_t x_173; uint8_t x_174; lean_object* x_175; uint8_t x_176; uint8_t x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; 
+if (lean_is_exclusive(x_149)) {
+ lean_ctor_release(x_149, 0);
+ lean_ctor_release(x_149, 1);
+ lean_ctor_release(x_149, 2);
+ x_157 = x_149;
 } else {
- lean_dec_ref(x_145);
- x_153 = lean_box(0);
+ lean_dec_ref(x_149);
+ x_157 = lean_box(0);
 }
-x_154 = lean_array_fget(x_146, x_147);
-x_155 = lean_unsigned_to_nat(1u);
-x_156 = lean_nat_add(x_147, x_155);
-lean_dec(x_147);
-if (lean_is_scalar(x_153)) {
- x_157 = lean_alloc_ctor(0, 3, 0);
+x_158 = lean_array_fget(x_150, x_151);
+x_159 = lean_unsigned_to_nat(1u);
+x_160 = lean_nat_add(x_151, x_159);
+lean_dec(x_151);
+if (lean_is_scalar(x_157)) {
+ x_161 = lean_alloc_ctor(0, 3, 0);
 } else {
- x_157 = x_153;
+ x_161 = x_157;
 }
-lean_ctor_set(x_157, 0, x_146);
-lean_ctor_set(x_157, 1, x_156);
-lean_ctor_set(x_157, 2, x_148);
-x_158 = lean_ctor_get(x_4, 0);
-lean_inc(x_158);
-x_159 = lean_ctor_get(x_4, 1);
-lean_inc(x_159);
-x_160 = lean_ctor_get(x_4, 2);
-lean_inc(x_160);
-x_161 = lean_ctor_get(x_4, 3);
-lean_inc(x_161);
+lean_ctor_set(x_161, 0, x_150);
+lean_ctor_set(x_161, 1, x_160);
+lean_ctor_set(x_161, 2, x_152);
+x_162 = lean_ctor_get(x_4, 0);
+lean_inc(x_162);
+x_163 = lean_ctor_get(x_4, 1);
+lean_inc(x_163);
+x_164 = lean_ctor_get(x_4, 2);
+lean_inc(x_164);
+x_165 = lean_ctor_get(x_4, 3);
+lean_inc(x_165);
 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);
- x_162 = x_4;
+ x_166 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_162 = lean_box(0);
+ x_166 = lean_box(0);
 }
-x_163 = lean_ctor_get_uint8(x_158, 0);
-x_164 = lean_ctor_get_uint8(x_158, 1);
-x_165 = lean_ctor_get_uint8(x_158, 2);
-x_166 = lean_ctor_get_uint8(x_158, 3);
-x_167 = lean_ctor_get_uint8(x_158, 4);
-x_168 = lean_ctor_get_uint8(x_158, 6);
-x_169 = lean_ctor_get_uint8(x_158, 7);
-x_170 = lean_ctor_get_uint8(x_158, 8);
-if (lean_is_exclusive(x_158)) {
- x_171 = x_158;
+x_167 = lean_ctor_get_uint8(x_162, 0);
+x_168 = lean_ctor_get_uint8(x_162, 1);
+x_169 = lean_ctor_get_uint8(x_162, 2);
+x_170 = lean_ctor_get_uint8(x_162, 3);
+x_171 = lean_ctor_get_uint8(x_162, 4);
+x_172 = lean_ctor_get_uint8(x_162, 6);
+x_173 = lean_ctor_get_uint8(x_162, 7);
+x_174 = lean_ctor_get_uint8(x_162, 8);
+if (lean_is_exclusive(x_162)) {
+ x_175 = x_162;
 } else {
- lean_dec_ref(x_158);
- x_171 = lean_box(0);
+ lean_dec_ref(x_162);
+ x_175 = lean_box(0);
 }
-x_172 = 2;
-if (lean_is_scalar(x_171)) {
- x_173 = lean_alloc_ctor(0, 0, 9);
+x_176 = 2;
+x_177 = 0;
+if (lean_is_scalar(x_175)) {
+ x_178 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_173 = x_171;
+ x_178 = x_175;
 }
-lean_ctor_set_uint8(x_173, 0, x_163);
-lean_ctor_set_uint8(x_173, 1, x_164);
-lean_ctor_set_uint8(x_173, 2, x_165);
-lean_ctor_set_uint8(x_173, 3, x_166);
-lean_ctor_set_uint8(x_173, 4, x_167);
-lean_ctor_set_uint8(x_173, 5, x_172);
-lean_ctor_set_uint8(x_173, 6, x_168);
-lean_ctor_set_uint8(x_173, 7, x_169);
-lean_ctor_set_uint8(x_173, 8, x_170);
-if (lean_is_scalar(x_162)) {
- x_174 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set_uint8(x_178, 0, x_167);
+lean_ctor_set_uint8(x_178, 1, x_168);
+lean_ctor_set_uint8(x_178, 2, x_169);
+lean_ctor_set_uint8(x_178, 3, x_170);
+lean_ctor_set_uint8(x_178, 4, x_171);
+lean_ctor_set_uint8(x_178, 5, x_176);
+lean_ctor_set_uint8(x_178, 6, x_172);
+lean_ctor_set_uint8(x_178, 7, x_173);
+lean_ctor_set_uint8(x_178, 8, x_174);
+lean_ctor_set_uint8(x_178, 9, x_177);
+if (lean_is_scalar(x_166)) {
+ x_179 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_174 = x_162;
+ x_179 = x_166;
 }
-lean_ctor_set(x_174, 0, x_173);
-lean_ctor_set(x_174, 1, x_159);
-lean_ctor_set(x_174, 2, x_160);
-lean_ctor_set(x_174, 3, x_161);
-x_175 = l_Lean_Meta_isExprDefEq(x_3, x_154, x_174, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_175) == 0)
+lean_ctor_set(x_179, 0, x_178);
+lean_ctor_set(x_179, 1, x_163);
+lean_ctor_set(x_179, 2, x_164);
+lean_ctor_set(x_179, 3, x_165);
+x_180 = l_Lean_Meta_isExprDefEq(x_3, x_158, x_179, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_180) == 0)
 {
-lean_object* x_176; uint8_t x_177; 
-x_176 = lean_ctor_get(x_175, 0);
-lean_inc(x_176);
-x_177 = lean_unbox(x_176);
-lean_dec(x_176);
-if (x_177 == 0)
+lean_object* x_181; uint8_t x_182; 
+x_181 = lean_ctor_get(x_180, 0);
+lean_inc(x_181);
+x_182 = lean_unbox(x_181);
+lean_dec(x_181);
+if (x_182 == 0)
 {
-lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; 
+lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; 
 lean_dec(x_2);
-x_178 = lean_ctor_get(x_175, 1);
-lean_inc(x_178);
-if (lean_is_exclusive(x_175)) {
- lean_ctor_release(x_175, 0);
- lean_ctor_release(x_175, 1);
- x_179 = x_175;
+x_183 = lean_ctor_get(x_180, 1);
+lean_inc(x_183);
+if (lean_is_exclusive(x_180)) {
+ lean_ctor_release(x_180, 0);
+ lean_ctor_release(x_180, 1);
+ x_184 = x_180;
 } else {
- lean_dec_ref(x_175);
- x_179 = lean_box(0);
-}
-x_180 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
-x_181 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_181, 0, x_180);
-lean_ctor_set(x_181, 1, x_157);
-x_182 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_182, 0, x_181);
-if (lean_is_scalar(x_179)) {
- x_183 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_183 = x_179;
-}
-lean_ctor_set(x_183, 0, x_182);
-lean_ctor_set(x_183, 1, x_178);
-return x_183;
-}
-else
-{
-lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; 
-x_184 = lean_ctor_get(x_175, 1);
-lean_inc(x_184);
-if (lean_is_exclusive(x_175)) {
- lean_ctor_release(x_175, 0);
- lean_ctor_release(x_175, 1);
- x_185 = x_175;
-} else {
- lean_dec_ref(x_175);
- x_185 = lean_box(0);
+ lean_dec_ref(x_180);
+ x_184 = lean_box(0);
 }
+x_185 = l_Lean_Syntax_instForInTopDownSyntax_loop___at_Lean_Syntax_hasMissing___spec__1___closed__2;
 x_186 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_186, 0, x_2);
-lean_ctor_set(x_186, 1, x_157);
-x_187 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_186, 0, x_185);
+lean_ctor_set(x_186, 1, x_161);
+x_187 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_187, 0, x_186);
-if (lean_is_scalar(x_185)) {
+if (lean_is_scalar(x_184)) {
  x_188 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_188 = x_185;
+ x_188 = x_184;
 }
 lean_ctor_set(x_188, 0, x_187);
-lean_ctor_set(x_188, 1, x_184);
+lean_ctor_set(x_188, 1, x_183);
 return x_188;
 }
+else
+{
+lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; 
+x_189 = lean_ctor_get(x_180, 1);
+lean_inc(x_189);
+if (lean_is_exclusive(x_180)) {
+ lean_ctor_release(x_180, 0);
+ lean_ctor_release(x_180, 1);
+ x_190 = x_180;
+} else {
+ lean_dec_ref(x_180);
+ x_190 = lean_box(0);
+}
+x_191 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_191, 0, x_2);
+lean_ctor_set(x_191, 1, x_161);
+x_192 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_192, 0, x_191);
+if (lean_is_scalar(x_190)) {
+ x_193 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_193 = x_190;
+}
+lean_ctor_set(x_193, 0, x_192);
+lean_ctor_set(x_193, 1, x_189);
+return x_193;
+}
 }
 else
 {
-lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; 
-lean_dec(x_157);
+lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; 
+lean_dec(x_161);
 lean_dec(x_2);
-x_189 = lean_ctor_get(x_175, 0);
-lean_inc(x_189);
-x_190 = lean_ctor_get(x_175, 1);
-lean_inc(x_190);
-if (lean_is_exclusive(x_175)) {
- lean_ctor_release(x_175, 0);
- lean_ctor_release(x_175, 1);
- x_191 = x_175;
+x_194 = lean_ctor_get(x_180, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_180, 1);
+lean_inc(x_195);
+if (lean_is_exclusive(x_180)) {
+ lean_ctor_release(x_180, 0);
+ lean_ctor_release(x_180, 1);
+ x_196 = x_180;
 } else {
- lean_dec_ref(x_175);
- x_191 = lean_box(0);
+ lean_dec_ref(x_180);
+ x_196 = lean_box(0);
 }
-if (lean_is_scalar(x_191)) {
- x_192 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_196)) {
+ x_197 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_192 = x_191;
+ x_197 = x_196;
 }
-lean_ctor_set(x_192, 0, x_189);
-lean_ctor_set(x_192, 1, x_190);
-return x_192;
+lean_ctor_set(x_197, 0, x_194);
+lean_ctor_set(x_197, 1, x_195);
+return x_197;
 }
 }
 }
@@ -3546,7 +3556,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_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_Structural_findRecArg_loop___spec__2___closed__1;
 x_2 = l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_Structural_findRecArg_loop___spec__2___closed__2;
-x_3 = lean_unsigned_to_nat(150u);
+x_3 = lean_unsigned_to_nat(166u);
 x_4 = lean_unsigned_to_nat(119u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -15633,7 +15643,7 @@ return x_42;
 }
 }
 }
-lean_object* l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural___hyg_5133_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural___hyg_5135_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -15875,7 +15885,7 @@ l_Lean_Elab_Structural_structuralRecursion___closed__2 = _init_l_Lean_Elab_Struc
 lean_mark_persistent(l_Lean_Elab_Structural_structuralRecursion___closed__2);
 l_Lean_Elab_Structural_structuralRecursion___closed__3 = _init_l_Lean_Elab_Structural_structuralRecursion___closed__3();
 lean_mark_persistent(l_Lean_Elab_Structural_structuralRecursion___closed__3);
-res = l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural___hyg_5133_(lean_io_mk_world());
+res = l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural___hyg_5135_(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));
diff --git a/stage0/stdlib/Lean/Elab/Quotation.c b/stage0/stdlib/Lean/Elab/Quotation.c
index c0a47fe6b9..6b9ac9905a 100644
--- a/stage0/stdlib/Lean/Elab/Quotation.c
+++ b/stage0/stdlib/Lean/Elab/Quotation.c
@@ -262,7 +262,6 @@ lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Quotation_0__Lean
 extern lean_object* l_Lean_instToMessageDataOption___rarg___closed__4;
 lean_object* l_Lean_Elab_Term_Quotation_match__syntax_expand(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nameLitKind;
-uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__2___boxed__const__1;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__17___boxed(lean_object**);
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__23___closed__5;
@@ -406,7 +405,6 @@ lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Quotation_0__Lean
 lean_object* l_Lean_Elab_Term_Quotation_mkTuple___closed__9;
 extern lean_object* l_Lean_Parser_Syntax_addPrec___closed__5;
 extern lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__43;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_List_forIn_loop___at___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___closed__6;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___closed__21;
@@ -515,6 +513,7 @@ uint8_t l_Array_isEmpty___rarg(lean_object*);
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo_match__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedSyntax;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__23___closed__10;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l___private_Init_Meta_0__Lean_quoteList___at___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___spec__9___boxed(lean_object*);
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo_match__9___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__7;
@@ -946,6 +945,7 @@ lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Syntax_SepArray_getElems___spec
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__23___closed__13;
 lean_object* l_Lean_Elab_Term_Quotation_match__syntax_expand___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__21___boxed(lean_object**);
+uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__11;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__22___closed__7;
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___spec__7___closed__13;
@@ -11866,7 +11866,7 @@ lean_ctor_set(x_72, 2, x_69);
 lean_ctor_set(x_72, 3, x_71);
 x_73 = lean_array_push(x_26, x_67);
 x_74 = lean_array_push(x_73, x_72);
-x_75 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_75 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_76 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_76, 0, x_75);
 lean_ctor_set(x_76, 1, x_74);
@@ -12063,7 +12063,7 @@ lean_ctor_set(x_178, 2, x_175);
 lean_ctor_set(x_178, 3, x_177);
 x_179 = lean_array_push(x_132, x_173);
 x_180 = lean_array_push(x_179, x_178);
-x_181 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_181 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_182 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_182, 0, x_181);
 lean_ctor_set(x_182, 1, x_180);
@@ -15924,7 +15924,7 @@ return x_8;
 else
 {
 uint8_t x_9; 
-x_9 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(x_6, x_2);
+x_9 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(x_6, x_2);
 if (x_9 == 0)
 {
 lean_object* x_10; 
diff --git a/stage0/stdlib/Lean/Elab/Syntax.c b/stage0/stdlib/Lean/Elab/Syntax.c
index 4c0e680277..9dac2a9e0d 100644
--- a/stage0/stdlib/Lean/Elab/Syntax.c
+++ b/stage0/stdlib/Lean/Elab/Syntax.c
@@ -427,7 +427,6 @@ lean_object* l_Lean_Elab_Command_elabSyntaxAbbrev___closed__16;
 lean_object* l_Lean_Elab_Command_elabSyntax_match__2___rarg(lean_object*, lean_object*);
 extern lean_object* l_stx___x3c_x7c_x3e_____closed__6;
 lean_object* l_Lean_Elab_Command_mkSimpleDelab___closed__5;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Elab_Term_toParserDescr_processNonReserved___closed__7;
 lean_object* l_Lean_Elab_Command_elabSyntax___lambda__3___closed__8;
 lean_object* l_Lean_Elab_Command_expandElab___lambda__2___closed__24;
@@ -557,6 +556,7 @@ extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____close
 extern lean_object* l_Lean_instInhabitedSyntax;
 lean_object* l_Lean_Elab_Term_toParserDescr_processParserCategory___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_expandElab___lambda__2___closed__5;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 extern lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
 lean_object* l_Lean_Elab_Command_elabCommand(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_expandElab___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -593,6 +593,7 @@ lean_object* l_Lean_Elab_Command_elabSyntax___lambda__2(lean_object*, lean_objec
 lean_object* l_Lean_Elab_Command_elabSyntax___lambda__3___closed__10;
 lean_object* l_Lean_Elab_Command_expandElab___lambda__2___closed__18;
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_object* l_Lean_Elab_resolveGlobalConstWithInfos___at_Lean_Elab_Term_toParserDescr_resolveParserName___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_toParserDescr_processNonReserved___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabSyntaxAbbrev___closed__6;
@@ -680,7 +681,6 @@ lean_object* l_Lean_throwErrorAt___at_Lean_Elab_Term_checkLeftRec___spec__6(lean
 lean_object* l_Lean_Syntax_getNumArgs(lean_object*);
 extern lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__1;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_toParserDescr_process___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
 lean_object* l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_declareSyntaxCatQuotParser___closed__31;
 lean_object* l_Lean_Elab_Term_toParserDescr_processNonReserved___closed__6;
@@ -12641,7 +12641,7 @@ lean_ctor_set(x_69, 2, x_66);
 lean_ctor_set(x_69, 3, x_68);
 x_70 = lean_array_push(x_28, x_64);
 x_71 = lean_array_push(x_70, x_69);
-x_72 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_72 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_73 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_73, 0, x_72);
 lean_ctor_set(x_73, 1, x_71);
@@ -14712,7 +14712,7 @@ lean_ctor_set(x_99, 1, x_97);
 x_100 = l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__24;
 lean_inc(x_4);
 x_101 = lean_name_mk_string(x_4, x_100);
-x_102 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_102 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_inc(x_5);
 x_103 = lean_name_mk_string(x_5, x_102);
 x_104 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
@@ -14975,7 +14975,7 @@ lean_ctor_set(x_245, 1, x_243);
 x_246 = l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__24;
 lean_inc(x_4);
 x_247 = lean_name_mk_string(x_4, x_246);
-x_248 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_248 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_inc(x_5);
 x_249 = lean_name_mk_string(x_5, x_248);
 x_250 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
@@ -15251,7 +15251,7 @@ lean_ctor_set(x_399, 1, x_397);
 x_400 = l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__24;
 lean_inc(x_4);
 x_401 = lean_name_mk_string(x_4, x_400);
-x_402 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_402 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_inc(x_5);
 x_403 = lean_name_mk_string(x_5, x_402);
 x_404 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
@@ -15515,7 +15515,7 @@ lean_ctor_set(x_546, 1, x_544);
 x_547 = l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__24;
 lean_inc(x_4);
 x_548 = lean_name_mk_string(x_4, x_547);
-x_549 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_549 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_inc(x_5);
 x_550 = lean_name_mk_string(x_5, x_549);
 x_551 = l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
@@ -17343,7 +17343,7 @@ lean_ctor_set(x_62, 3, x_61);
 x_63 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_64 = lean_array_push(x_63, x_56);
 x_65 = lean_array_push(x_64, x_62);
-x_66 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_66 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_67 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_67, 0, x_66);
 lean_ctor_set(x_67, 1, x_65);
@@ -18495,7 +18495,7 @@ lean_ctor_set(x_81, 2, x_78);
 lean_ctor_set(x_81, 3, x_80);
 x_82 = lean_array_push(x_32, x_76);
 x_83 = lean_array_push(x_82, x_81);
-x_84 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_84 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_85 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_85, 0, x_84);
 lean_ctor_set(x_85, 1, x_83);
@@ -18733,7 +18733,7 @@ lean_ctor_set(x_212, 2, x_209);
 lean_ctor_set(x_212, 3, x_211);
 x_213 = lean_array_push(x_163, x_207);
 x_214 = lean_array_push(x_213, x_212);
-x_215 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_215 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_216 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_216, 0, x_215);
 lean_ctor_set(x_216, 1, x_214);
@@ -20525,7 +20525,7 @@ lean_ctor_set(x_132, 2, x_129);
 lean_ctor_set(x_132, 3, x_131);
 x_133 = lean_array_push(x_83, x_127);
 x_134 = lean_array_push(x_133, x_132);
-x_135 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_135 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_136 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_136, 0, x_135);
 lean_ctor_set(x_136, 1, x_134);
@@ -20700,7 +20700,7 @@ lean_ctor_set(x_231, 2, x_228);
 lean_ctor_set(x_231, 3, x_230);
 x_232 = lean_array_push(x_182, x_226);
 x_233 = lean_array_push(x_232, x_231);
-x_234 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_234 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_235 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_235, 0, x_234);
 lean_ctor_set(x_235, 1, x_233);
@@ -25005,7 +25005,7 @@ lean_ctor_set(x_92, 2, x_89);
 lean_ctor_set(x_92, 3, x_91);
 x_93 = lean_array_push(x_46, x_87);
 x_94 = lean_array_push(x_93, x_92);
-x_95 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_95 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_96 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_96, 0, x_95);
 lean_ctor_set(x_96, 1, x_94);
@@ -25221,7 +25221,7 @@ lean_ctor_set(x_211, 2, x_208);
 lean_ctor_set(x_211, 3, x_210);
 x_212 = lean_array_push(x_165, x_206);
 x_213 = lean_array_push(x_212, x_211);
-x_214 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_214 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_215 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_215, 0, x_214);
 lean_ctor_set(x_215, 1, x_213);
@@ -25451,7 +25451,7 @@ lean_ctor_set(x_334, 2, x_331);
 lean_ctor_set(x_334, 3, x_333);
 x_335 = lean_array_push(x_288, x_329);
 x_336 = lean_array_push(x_335, x_334);
-x_337 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_337 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_338 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_338, 0, x_337);
 lean_ctor_set(x_338, 1, x_336);
@@ -26016,7 +26016,7 @@ lean_ctor_set(x_509, 2, x_506);
 lean_ctor_set(x_509, 3, x_508);
 x_510 = lean_array_push(x_463, x_504);
 x_511 = lean_array_push(x_510, x_509);
-x_512 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_512 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_513 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_513, 0, x_512);
 lean_ctor_set(x_513, 1, x_511);
@@ -26301,7 +26301,7 @@ lean_ctor_set(x_663, 2, x_660);
 lean_ctor_set(x_663, 3, x_662);
 x_664 = lean_array_push(x_617, x_658);
 x_665 = lean_array_push(x_664, x_663);
-x_666 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_666 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_667 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_667, 0, x_666);
 lean_ctor_set(x_667, 1, x_665);
@@ -26600,7 +26600,7 @@ lean_ctor_set(x_821, 2, x_818);
 lean_ctor_set(x_821, 3, x_820);
 x_822 = lean_array_push(x_775, x_816);
 x_823 = lean_array_push(x_822, x_821);
-x_824 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_824 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_825 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_825, 0, x_824);
 lean_ctor_set(x_825, 1, x_823);
@@ -27049,7 +27049,7 @@ lean_ctor_set(x_1040, 2, x_1037);
 lean_ctor_set(x_1040, 3, x_1039);
 x_1041 = lean_array_push(x_994, x_1035);
 x_1042 = lean_array_push(x_1041, x_1040);
-x_1043 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1043 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_1044 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_1044, 0, x_1043);
 lean_ctor_set(x_1044, 1, x_1042);
@@ -27334,7 +27334,7 @@ lean_ctor_set(x_1194, 2, x_1191);
 lean_ctor_set(x_1194, 3, x_1193);
 x_1195 = lean_array_push(x_1148, x_1189);
 x_1196 = lean_array_push(x_1195, x_1194);
-x_1197 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1197 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_1198 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_1198, 0, x_1197);
 lean_ctor_set(x_1198, 1, x_1196);
@@ -27633,7 +27633,7 @@ lean_ctor_set(x_1352, 2, x_1349);
 lean_ctor_set(x_1352, 3, x_1351);
 x_1353 = lean_array_push(x_1306, x_1347);
 x_1354 = lean_array_push(x_1353, x_1352);
-x_1355 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1355 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_1356 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_1356, 0, x_1355);
 lean_ctor_set(x_1356, 1, x_1354);
@@ -28084,7 +28084,7 @@ lean_ctor_set(x_1573, 2, x_1570);
 lean_ctor_set(x_1573, 3, x_1572);
 x_1574 = lean_array_push(x_1527, x_1568);
 x_1575 = lean_array_push(x_1574, x_1573);
-x_1576 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1576 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_1577 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_1577, 0, x_1576);
 lean_ctor_set(x_1577, 1, x_1575);
@@ -28369,7 +28369,7 @@ lean_ctor_set(x_1727, 2, x_1724);
 lean_ctor_set(x_1727, 3, x_1726);
 x_1728 = lean_array_push(x_1681, x_1722);
 x_1729 = lean_array_push(x_1728, x_1727);
-x_1730 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1730 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_1731 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_1731, 0, x_1730);
 lean_ctor_set(x_1731, 1, x_1729);
@@ -28668,7 +28668,7 @@ lean_ctor_set(x_1885, 2, x_1882);
 lean_ctor_set(x_1885, 3, x_1884);
 x_1886 = lean_array_push(x_1839, x_1880);
 x_1887 = lean_array_push(x_1886, x_1885);
-x_1888 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1888 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_1889 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_1889, 0, x_1888);
 lean_ctor_set(x_1889, 1, x_1887);
@@ -29113,7 +29113,7 @@ lean_ctor_set(x_2110, 2, x_2107);
 lean_ctor_set(x_2110, 3, x_2109);
 x_2111 = lean_array_push(x_2064, x_2105);
 x_2112 = lean_array_push(x_2111, x_2110);
-x_2113 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_2113 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2114 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_2114, 0, x_2113);
 lean_ctor_set(x_2114, 1, x_2112);
@@ -29539,7 +29539,7 @@ lean_ctor_set(x_2311, 2, x_2308);
 lean_ctor_set(x_2311, 3, x_2310);
 x_2312 = lean_array_push(x_2265, x_2306);
 x_2313 = lean_array_push(x_2312, x_2311);
-x_2314 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_2314 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2315 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_2315, 0, x_2314);
 lean_ctor_set(x_2315, 1, x_2313);
@@ -29967,7 +29967,7 @@ lean_ctor_set(x_2514, 2, x_2511);
 lean_ctor_set(x_2514, 3, x_2513);
 x_2515 = lean_array_push(x_2468, x_2509);
 x_2516 = lean_array_push(x_2515, x_2514);
-x_2517 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_2517 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2518 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_2518, 0, x_2517);
 lean_ctor_set(x_2518, 1, x_2516);
@@ -36433,7 +36433,7 @@ lean_ctor_set(x_113, 2, x_110);
 lean_ctor_set(x_113, 3, x_112);
 x_114 = lean_array_push(x_68, x_108);
 x_115 = lean_array_push(x_114, x_113);
-x_116 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_116 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_117 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_117, 0, x_116);
 lean_ctor_set(x_117, 1, x_115);
@@ -36714,7 +36714,7 @@ lean_ctor_set(x_261, 2, x_258);
 lean_ctor_set(x_261, 3, x_260);
 x_262 = lean_array_push(x_216, x_256);
 x_263 = lean_array_push(x_262, x_261);
-x_264 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_264 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_265 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_265, 0, x_264);
 lean_ctor_set(x_265, 1, x_263);
@@ -36995,7 +36995,7 @@ lean_ctor_set(x_409, 2, x_406);
 lean_ctor_set(x_409, 3, x_408);
 x_410 = lean_array_push(x_364, x_404);
 x_411 = lean_array_push(x_410, x_409);
-x_412 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_412 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_413 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_413, 0, x_412);
 lean_ctor_set(x_413, 1, x_411);
@@ -37378,7 +37378,7 @@ lean_ctor_set(x_601, 2, x_598);
 lean_ctor_set(x_601, 3, x_600);
 x_602 = lean_array_push(x_556, x_596);
 x_603 = lean_array_push(x_602, x_601);
-x_604 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_604 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_605 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_605, 0, x_604);
 lean_ctor_set(x_605, 1, x_603);
diff --git a/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c b/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c
index 92b861a736..f06a24e197 100644
--- a/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c
+++ b/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c
@@ -3108,7 +3108,7 @@ return x_25;
 }
 else
 {
-uint8_t x_26; uint8_t x_27; 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; lean_object* x_35; lean_object* x_36; 
+uint8_t x_26; uint8_t x_27; 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; lean_object* x_36; lean_object* x_37; 
 x_26 = lean_ctor_get_uint8(x_14, 0);
 x_27 = lean_ctor_get_uint8(x_14, 1);
 x_28 = lean_ctor_get_uint8(x_14, 2);
@@ -3117,164 +3117,168 @@ x_30 = lean_ctor_get_uint8(x_14, 4);
 x_31 = lean_ctor_get_uint8(x_14, 6);
 x_32 = lean_ctor_get_uint8(x_14, 7);
 x_33 = lean_ctor_get_uint8(x_14, 8);
+x_34 = lean_ctor_get_uint8(x_14, 9);
 lean_dec(x_14);
-x_34 = 2;
-x_35 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_35, 0, x_26);
-lean_ctor_set_uint8(x_35, 1, x_27);
-lean_ctor_set_uint8(x_35, 2, x_28);
-lean_ctor_set_uint8(x_35, 3, x_29);
-lean_ctor_set_uint8(x_35, 4, x_30);
-lean_ctor_set_uint8(x_35, 5, x_34);
-lean_ctor_set_uint8(x_35, 6, x_31);
-lean_ctor_set_uint8(x_35, 7, x_32);
-lean_ctor_set_uint8(x_35, 8, x_33);
-lean_ctor_set(x_6, 0, x_35);
-x_36 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_36) == 0)
+x_35 = 2;
+x_36 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_36, 0, x_26);
+lean_ctor_set_uint8(x_36, 1, x_27);
+lean_ctor_set_uint8(x_36, 2, x_28);
+lean_ctor_set_uint8(x_36, 3, x_29);
+lean_ctor_set_uint8(x_36, 4, x_30);
+lean_ctor_set_uint8(x_36, 5, x_35);
+lean_ctor_set_uint8(x_36, 6, x_31);
+lean_ctor_set_uint8(x_36, 7, x_32);
+lean_ctor_set_uint8(x_36, 8, x_33);
+lean_ctor_set_uint8(x_36, 9, x_34);
+lean_ctor_set(x_6, 0, x_36);
+x_37 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_37) == 0)
 {
-lean_object* x_37; lean_object* x_38; lean_object* 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_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_38 = lean_ctor_get(x_37, 0);
 lean_inc(x_38);
-if (lean_is_exclusive(x_36)) {
- lean_ctor_release(x_36, 0);
- lean_ctor_release(x_36, 1);
- x_39 = x_36;
+x_39 = lean_ctor_get(x_37, 1);
+lean_inc(x_39);
+if (lean_is_exclusive(x_37)) {
+ lean_ctor_release(x_37, 0);
+ lean_ctor_release(x_37, 1);
+ x_40 = x_37;
 } else {
- lean_dec_ref(x_36);
- x_39 = lean_box(0);
+ lean_dec_ref(x_37);
+ x_40 = lean_box(0);
 }
-if (lean_is_scalar(x_39)) {
- x_40 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_40)) {
+ x_41 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_40 = x_39;
+ x_41 = x_40;
 }
-lean_ctor_set(x_40, 0, x_37);
-lean_ctor_set(x_40, 1, x_38);
-return x_40;
+lean_ctor_set(x_41, 0, x_38);
+lean_ctor_set(x_41, 1, x_39);
+return x_41;
 }
 else
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_41 = lean_ctor_get(x_36, 0);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_36, 1);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+x_42 = lean_ctor_get(x_37, 0);
 lean_inc(x_42);
-if (lean_is_exclusive(x_36)) {
- lean_ctor_release(x_36, 0);
- lean_ctor_release(x_36, 1);
- x_43 = x_36;
+x_43 = lean_ctor_get(x_37, 1);
+lean_inc(x_43);
+if (lean_is_exclusive(x_37)) {
+ lean_ctor_release(x_37, 0);
+ lean_ctor_release(x_37, 1);
+ x_44 = x_37;
 } else {
- lean_dec_ref(x_36);
- x_43 = lean_box(0);
+ lean_dec_ref(x_37);
+ x_44 = lean_box(0);
 }
-if (lean_is_scalar(x_43)) {
- x_44 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_44)) {
+ x_45 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_44 = x_43;
+ x_45 = x_44;
 }
-lean_ctor_set(x_44, 0, x_41);
-lean_ctor_set(x_44, 1, x_42);
-return x_44;
+lean_ctor_set(x_45, 0, x_42);
+lean_ctor_set(x_45, 1, x_43);
+return x_45;
 }
 }
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_45 = lean_ctor_get(x_6, 0);
-x_46 = lean_ctor_get(x_6, 1);
-x_47 = lean_ctor_get(x_6, 2);
-x_48 = lean_ctor_get(x_6, 3);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_46 = lean_ctor_get(x_6, 0);
+x_47 = lean_ctor_get(x_6, 1);
+x_48 = lean_ctor_get(x_6, 2);
+x_49 = lean_ctor_get(x_6, 3);
+lean_inc(x_49);
 lean_inc(x_48);
 lean_inc(x_47);
 lean_inc(x_46);
-lean_inc(x_45);
 lean_dec(x_6);
-x_49 = lean_ctor_get_uint8(x_45, 0);
-x_50 = lean_ctor_get_uint8(x_45, 1);
-x_51 = lean_ctor_get_uint8(x_45, 2);
-x_52 = lean_ctor_get_uint8(x_45, 3);
-x_53 = lean_ctor_get_uint8(x_45, 4);
-x_54 = lean_ctor_get_uint8(x_45, 6);
-x_55 = lean_ctor_get_uint8(x_45, 7);
-x_56 = lean_ctor_get_uint8(x_45, 8);
-if (lean_is_exclusive(x_45)) {
- x_57 = x_45;
+x_50 = lean_ctor_get_uint8(x_46, 0);
+x_51 = lean_ctor_get_uint8(x_46, 1);
+x_52 = lean_ctor_get_uint8(x_46, 2);
+x_53 = lean_ctor_get_uint8(x_46, 3);
+x_54 = lean_ctor_get_uint8(x_46, 4);
+x_55 = lean_ctor_get_uint8(x_46, 6);
+x_56 = lean_ctor_get_uint8(x_46, 7);
+x_57 = lean_ctor_get_uint8(x_46, 8);
+x_58 = lean_ctor_get_uint8(x_46, 9);
+if (lean_is_exclusive(x_46)) {
+ x_59 = x_46;
 } else {
- lean_dec_ref(x_45);
- x_57 = lean_box(0);
+ lean_dec_ref(x_46);
+ x_59 = lean_box(0);
 }
-x_58 = 2;
-if (lean_is_scalar(x_57)) {
- x_59 = lean_alloc_ctor(0, 0, 9);
+x_60 = 2;
+if (lean_is_scalar(x_59)) {
+ x_61 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_59 = x_57;
+ x_61 = x_59;
 }
-lean_ctor_set_uint8(x_59, 0, x_49);
-lean_ctor_set_uint8(x_59, 1, x_50);
-lean_ctor_set_uint8(x_59, 2, x_51);
-lean_ctor_set_uint8(x_59, 3, x_52);
-lean_ctor_set_uint8(x_59, 4, x_53);
-lean_ctor_set_uint8(x_59, 5, x_58);
-lean_ctor_set_uint8(x_59, 6, x_54);
-lean_ctor_set_uint8(x_59, 7, x_55);
-lean_ctor_set_uint8(x_59, 8, x_56);
-x_60 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_60, 0, x_59);
-lean_ctor_set(x_60, 1, x_46);
-lean_ctor_set(x_60, 2, x_47);
-lean_ctor_set(x_60, 3, x_48);
-x_61 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_60, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_61) == 0)
+lean_ctor_set_uint8(x_61, 0, x_50);
+lean_ctor_set_uint8(x_61, 1, x_51);
+lean_ctor_set_uint8(x_61, 2, x_52);
+lean_ctor_set_uint8(x_61, 3, x_53);
+lean_ctor_set_uint8(x_61, 4, x_54);
+lean_ctor_set_uint8(x_61, 5, x_60);
+lean_ctor_set_uint8(x_61, 6, x_55);
+lean_ctor_set_uint8(x_61, 7, x_56);
+lean_ctor_set_uint8(x_61, 8, x_57);
+lean_ctor_set_uint8(x_61, 9, x_58);
+x_62 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_62, 0, x_61);
+lean_ctor_set(x_62, 1, x_47);
+lean_ctor_set(x_62, 2, x_48);
+lean_ctor_set(x_62, 3, x_49);
+x_63 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_62, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_63) == 0)
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
-x_63 = lean_ctor_get(x_61, 1);
-lean_inc(x_63);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- lean_ctor_release(x_61, 1);
- x_64 = x_61;
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_64 = lean_ctor_get(x_63, 0);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_63, 1);
+lean_inc(x_65);
+if (lean_is_exclusive(x_63)) {
+ lean_ctor_release(x_63, 0);
+ lean_ctor_release(x_63, 1);
+ x_66 = x_63;
 } else {
- lean_dec_ref(x_61);
- x_64 = lean_box(0);
+ lean_dec_ref(x_63);
+ x_66 = lean_box(0);
 }
-if (lean_is_scalar(x_64)) {
- x_65 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_66)) {
+ x_67 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_65 = x_64;
+ x_67 = x_66;
 }
-lean_ctor_set(x_65, 0, x_62);
-lean_ctor_set(x_65, 1, x_63);
-return x_65;
+lean_ctor_set(x_67, 0, x_64);
+lean_ctor_set(x_67, 1, x_65);
+return x_67;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_66 = lean_ctor_get(x_61, 0);
-lean_inc(x_66);
-x_67 = lean_ctor_get(x_61, 1);
-lean_inc(x_67);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- lean_ctor_release(x_61, 1);
- x_68 = x_61;
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_68 = lean_ctor_get(x_63, 0);
+lean_inc(x_68);
+x_69 = lean_ctor_get(x_63, 1);
+lean_inc(x_69);
+if (lean_is_exclusive(x_63)) {
+ lean_ctor_release(x_63, 0);
+ lean_ctor_release(x_63, 1);
+ x_70 = x_63;
 } else {
- lean_dec_ref(x_61);
- x_68 = lean_box(0);
+ lean_dec_ref(x_63);
+ x_70 = lean_box(0);
 }
-if (lean_is_scalar(x_68)) {
- x_69 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_70)) {
+ x_71 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_69 = x_68;
+ x_71 = x_70;
 }
-lean_ctor_set(x_69, 0, x_66);
-lean_ctor_set(x_69, 1, x_67);
-return x_69;
+lean_ctor_set(x_71, 0, x_68);
+lean_ctor_set(x_71, 1, x_69);
+return x_71;
 }
 }
 }
@@ -3372,7 +3376,7 @@ return x_25;
 }
 else
 {
-uint8_t x_26; uint8_t x_27; 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; lean_object* x_35; lean_object* x_36; 
+uint8_t x_26; uint8_t x_27; 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; lean_object* x_36; lean_object* x_37; 
 x_26 = lean_ctor_get_uint8(x_14, 0);
 x_27 = lean_ctor_get_uint8(x_14, 1);
 x_28 = lean_ctor_get_uint8(x_14, 2);
@@ -3381,164 +3385,168 @@ x_30 = lean_ctor_get_uint8(x_14, 4);
 x_31 = lean_ctor_get_uint8(x_14, 6);
 x_32 = lean_ctor_get_uint8(x_14, 7);
 x_33 = lean_ctor_get_uint8(x_14, 8);
+x_34 = lean_ctor_get_uint8(x_14, 9);
 lean_dec(x_14);
-x_34 = 3;
-x_35 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_35, 0, x_26);
-lean_ctor_set_uint8(x_35, 1, x_27);
-lean_ctor_set_uint8(x_35, 2, x_28);
-lean_ctor_set_uint8(x_35, 3, x_29);
-lean_ctor_set_uint8(x_35, 4, x_30);
-lean_ctor_set_uint8(x_35, 5, x_34);
-lean_ctor_set_uint8(x_35, 6, x_31);
-lean_ctor_set_uint8(x_35, 7, x_32);
-lean_ctor_set_uint8(x_35, 8, x_33);
-lean_ctor_set(x_6, 0, x_35);
-x_36 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_36) == 0)
+x_35 = 3;
+x_36 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_36, 0, x_26);
+lean_ctor_set_uint8(x_36, 1, x_27);
+lean_ctor_set_uint8(x_36, 2, x_28);
+lean_ctor_set_uint8(x_36, 3, x_29);
+lean_ctor_set_uint8(x_36, 4, x_30);
+lean_ctor_set_uint8(x_36, 5, x_35);
+lean_ctor_set_uint8(x_36, 6, x_31);
+lean_ctor_set_uint8(x_36, 7, x_32);
+lean_ctor_set_uint8(x_36, 8, x_33);
+lean_ctor_set_uint8(x_36, 9, x_34);
+lean_ctor_set(x_6, 0, x_36);
+x_37 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_37) == 0)
 {
-lean_object* x_37; lean_object* x_38; lean_object* 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_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_38 = lean_ctor_get(x_37, 0);
 lean_inc(x_38);
-if (lean_is_exclusive(x_36)) {
- lean_ctor_release(x_36, 0);
- lean_ctor_release(x_36, 1);
- x_39 = x_36;
+x_39 = lean_ctor_get(x_37, 1);
+lean_inc(x_39);
+if (lean_is_exclusive(x_37)) {
+ lean_ctor_release(x_37, 0);
+ lean_ctor_release(x_37, 1);
+ x_40 = x_37;
 } else {
- lean_dec_ref(x_36);
- x_39 = lean_box(0);
+ lean_dec_ref(x_37);
+ x_40 = lean_box(0);
 }
-if (lean_is_scalar(x_39)) {
- x_40 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_40)) {
+ x_41 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_40 = x_39;
+ x_41 = x_40;
 }
-lean_ctor_set(x_40, 0, x_37);
-lean_ctor_set(x_40, 1, x_38);
-return x_40;
+lean_ctor_set(x_41, 0, x_38);
+lean_ctor_set(x_41, 1, x_39);
+return x_41;
 }
 else
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_41 = lean_ctor_get(x_36, 0);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_36, 1);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+x_42 = lean_ctor_get(x_37, 0);
 lean_inc(x_42);
-if (lean_is_exclusive(x_36)) {
- lean_ctor_release(x_36, 0);
- lean_ctor_release(x_36, 1);
- x_43 = x_36;
+x_43 = lean_ctor_get(x_37, 1);
+lean_inc(x_43);
+if (lean_is_exclusive(x_37)) {
+ lean_ctor_release(x_37, 0);
+ lean_ctor_release(x_37, 1);
+ x_44 = x_37;
 } else {
- lean_dec_ref(x_36);
- x_43 = lean_box(0);
+ lean_dec_ref(x_37);
+ x_44 = lean_box(0);
 }
-if (lean_is_scalar(x_43)) {
- x_44 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_44)) {
+ x_45 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_44 = x_43;
+ x_45 = x_44;
 }
-lean_ctor_set(x_44, 0, x_41);
-lean_ctor_set(x_44, 1, x_42);
-return x_44;
+lean_ctor_set(x_45, 0, x_42);
+lean_ctor_set(x_45, 1, x_43);
+return x_45;
 }
 }
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_45 = lean_ctor_get(x_6, 0);
-x_46 = lean_ctor_get(x_6, 1);
-x_47 = lean_ctor_get(x_6, 2);
-x_48 = lean_ctor_get(x_6, 3);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_46 = lean_ctor_get(x_6, 0);
+x_47 = lean_ctor_get(x_6, 1);
+x_48 = lean_ctor_get(x_6, 2);
+x_49 = lean_ctor_get(x_6, 3);
+lean_inc(x_49);
 lean_inc(x_48);
 lean_inc(x_47);
 lean_inc(x_46);
-lean_inc(x_45);
 lean_dec(x_6);
-x_49 = lean_ctor_get_uint8(x_45, 0);
-x_50 = lean_ctor_get_uint8(x_45, 1);
-x_51 = lean_ctor_get_uint8(x_45, 2);
-x_52 = lean_ctor_get_uint8(x_45, 3);
-x_53 = lean_ctor_get_uint8(x_45, 4);
-x_54 = lean_ctor_get_uint8(x_45, 6);
-x_55 = lean_ctor_get_uint8(x_45, 7);
-x_56 = lean_ctor_get_uint8(x_45, 8);
-if (lean_is_exclusive(x_45)) {
- x_57 = x_45;
+x_50 = lean_ctor_get_uint8(x_46, 0);
+x_51 = lean_ctor_get_uint8(x_46, 1);
+x_52 = lean_ctor_get_uint8(x_46, 2);
+x_53 = lean_ctor_get_uint8(x_46, 3);
+x_54 = lean_ctor_get_uint8(x_46, 4);
+x_55 = lean_ctor_get_uint8(x_46, 6);
+x_56 = lean_ctor_get_uint8(x_46, 7);
+x_57 = lean_ctor_get_uint8(x_46, 8);
+x_58 = lean_ctor_get_uint8(x_46, 9);
+if (lean_is_exclusive(x_46)) {
+ x_59 = x_46;
 } else {
- lean_dec_ref(x_45);
- x_57 = lean_box(0);
+ lean_dec_ref(x_46);
+ x_59 = lean_box(0);
 }
-x_58 = 3;
-if (lean_is_scalar(x_57)) {
- x_59 = lean_alloc_ctor(0, 0, 9);
+x_60 = 3;
+if (lean_is_scalar(x_59)) {
+ x_61 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_59 = x_57;
+ x_61 = x_59;
 }
-lean_ctor_set_uint8(x_59, 0, x_49);
-lean_ctor_set_uint8(x_59, 1, x_50);
-lean_ctor_set_uint8(x_59, 2, x_51);
-lean_ctor_set_uint8(x_59, 3, x_52);
-lean_ctor_set_uint8(x_59, 4, x_53);
-lean_ctor_set_uint8(x_59, 5, x_58);
-lean_ctor_set_uint8(x_59, 6, x_54);
-lean_ctor_set_uint8(x_59, 7, x_55);
-lean_ctor_set_uint8(x_59, 8, x_56);
-x_60 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_60, 0, x_59);
-lean_ctor_set(x_60, 1, x_46);
-lean_ctor_set(x_60, 2, x_47);
-lean_ctor_set(x_60, 3, x_48);
-x_61 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_60, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_61) == 0)
+lean_ctor_set_uint8(x_61, 0, x_50);
+lean_ctor_set_uint8(x_61, 1, x_51);
+lean_ctor_set_uint8(x_61, 2, x_52);
+lean_ctor_set_uint8(x_61, 3, x_53);
+lean_ctor_set_uint8(x_61, 4, x_54);
+lean_ctor_set_uint8(x_61, 5, x_60);
+lean_ctor_set_uint8(x_61, 6, x_55);
+lean_ctor_set_uint8(x_61, 7, x_56);
+lean_ctor_set_uint8(x_61, 8, x_57);
+lean_ctor_set_uint8(x_61, 9, x_58);
+x_62 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_62, 0, x_61);
+lean_ctor_set(x_62, 1, x_47);
+lean_ctor_set(x_62, 2, x_48);
+lean_ctor_set(x_62, 3, x_49);
+x_63 = l_Lean_Elab_Tactic_evalTactic(x_12, x_2, x_3, x_4, x_5, x_62, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_63) == 0)
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
-x_63 = lean_ctor_get(x_61, 1);
-lean_inc(x_63);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- lean_ctor_release(x_61, 1);
- x_64 = x_61;
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_64 = lean_ctor_get(x_63, 0);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_63, 1);
+lean_inc(x_65);
+if (lean_is_exclusive(x_63)) {
+ lean_ctor_release(x_63, 0);
+ lean_ctor_release(x_63, 1);
+ x_66 = x_63;
 } else {
- lean_dec_ref(x_61);
- x_64 = lean_box(0);
+ lean_dec_ref(x_63);
+ x_66 = lean_box(0);
 }
-if (lean_is_scalar(x_64)) {
- x_65 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_66)) {
+ x_67 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_65 = x_64;
+ x_67 = x_66;
 }
-lean_ctor_set(x_65, 0, x_62);
-lean_ctor_set(x_65, 1, x_63);
-return x_65;
+lean_ctor_set(x_67, 0, x_64);
+lean_ctor_set(x_67, 1, x_65);
+return x_67;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_66 = lean_ctor_get(x_61, 0);
-lean_inc(x_66);
-x_67 = lean_ctor_get(x_61, 1);
-lean_inc(x_67);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- lean_ctor_release(x_61, 1);
- x_68 = x_61;
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_68 = lean_ctor_get(x_63, 0);
+lean_inc(x_68);
+x_69 = lean_ctor_get(x_63, 1);
+lean_inc(x_69);
+if (lean_is_exclusive(x_63)) {
+ lean_ctor_release(x_63, 0);
+ lean_ctor_release(x_63, 1);
+ x_70 = x_63;
 } else {
- lean_dec_ref(x_61);
- x_68 = lean_box(0);
+ lean_dec_ref(x_63);
+ x_70 = lean_box(0);
 }
-if (lean_is_scalar(x_68)) {
- x_69 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_70)) {
+ x_71 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_69 = x_68;
+ x_71 = x_70;
 }
-lean_ctor_set(x_69, 0, x_66);
-lean_ctor_set(x_69, 1, x_67);
-return x_69;
+lean_ctor_set(x_71, 0, x_68);
+lean_ctor_set(x_71, 1, x_69);
+return x_71;
 }
 }
 }
@@ -6130,7 +6138,7 @@ return x_47;
 }
 else
 {
-uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
 x_48 = lean_ctor_get_uint8(x_18, 0);
 x_49 = lean_ctor_get_uint8(x_18, 1);
 x_50 = lean_ctor_get_uint8(x_18, 2);
@@ -6139,95 +6147,97 @@ x_52 = lean_ctor_get_uint8(x_18, 4);
 x_53 = lean_ctor_get_uint8(x_18, 6);
 x_54 = lean_ctor_get_uint8(x_18, 7);
 x_55 = lean_ctor_get_uint8(x_18, 8);
+x_56 = lean_ctor_get_uint8(x_18, 9);
 lean_dec(x_18);
-x_56 = 1;
-x_57 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_57, 0, x_48);
-lean_ctor_set_uint8(x_57, 1, x_49);
-lean_ctor_set_uint8(x_57, 2, x_50);
-lean_ctor_set_uint8(x_57, 3, x_51);
-lean_ctor_set_uint8(x_57, 4, x_52);
-lean_ctor_set_uint8(x_57, 5, x_56);
-lean_ctor_set_uint8(x_57, 6, x_53);
-lean_ctor_set_uint8(x_57, 7, x_54);
-lean_ctor_set_uint8(x_57, 8, x_55);
-x_58 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set(x_58, 1, x_21);
-lean_ctor_set(x_58, 2, x_22);
-lean_ctor_set(x_58, 3, x_23);
+x_57 = 1;
+x_58 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_58, 0, x_48);
+lean_ctor_set_uint8(x_58, 1, x_49);
+lean_ctor_set_uint8(x_58, 2, x_50);
+lean_ctor_set_uint8(x_58, 3, x_51);
+lean_ctor_set_uint8(x_58, 4, x_52);
+lean_ctor_set_uint8(x_58, 5, x_57);
+lean_ctor_set_uint8(x_58, 6, x_53);
+lean_ctor_set_uint8(x_58, 7, x_54);
+lean_ctor_set_uint8(x_58, 8, x_55);
+lean_ctor_set_uint8(x_58, 9, x_56);
+x_59 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_59, 0, x_58);
+lean_ctor_set(x_59, 1, x_21);
+lean_ctor_set(x_59, 2, x_22);
+lean_ctor_set(x_59, 3, x_23);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_19);
-x_59 = l_Lean_Meta_whnf(x_19, x_58, x_7, x_8, x_9, x_20);
-if (lean_obj_tag(x_59) == 0)
+x_60 = l_Lean_Meta_whnf(x_19, x_59, x_7, x_8, x_9, x_20);
+if (lean_obj_tag(x_60) == 0)
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; 
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_59, 1);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_61 = lean_ctor_get(x_60, 0);
 lean_inc(x_61);
-lean_dec(x_59);
-x_62 = l_Lean_instQuoteBool___closed__5;
-x_63 = l_Lean_Expr_isConstOf(x_60, x_62);
-if (x_63 == 0)
-{
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-lean_dec(x_19);
-lean_dec(x_12);
-x_64 = l_Lean_indentExpr(x_60);
-x_65 = l_Lean_Elab_Tactic_evalDecide___rarg___lambda__2___closed__2;
-x_66 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_66, 0, x_65);
-lean_ctor_set(x_66, 1, x_64);
-x_67 = l_Lean_KernelException_toMessageData___closed__15;
-x_68 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_68, 0, x_66);
-lean_ctor_set(x_68, 1, x_67);
-x_69 = l_Lean_throwError___at_Lean_Elab_Tactic_evalTacticAux___spec__9(x_68, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_61);
-lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-x_70 = lean_ctor_get(x_69, 0);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_69, 1);
-lean_inc(x_71);
-if (lean_is_exclusive(x_69)) {
- lean_ctor_release(x_69, 0);
- lean_ctor_release(x_69, 1);
- x_72 = x_69;
-} else {
- lean_dec_ref(x_69);
- x_72 = lean_box(0);
-}
-if (lean_is_scalar(x_72)) {
- x_73 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_73 = x_72;
-}
-lean_ctor_set(x_73, 0, x_70);
-lean_ctor_set(x_73, 1, x_71);
-return x_73;
-}
-else
-{
-lean_object* x_74; lean_object* x_75; 
+x_62 = lean_ctor_get(x_60, 1);
+lean_inc(x_62);
 lean_dec(x_60);
-x_74 = lean_box(0);
-x_75 = l_Lean_Elab_Tactic_evalDecide___rarg___lambda__1(x_19, x_12, x_74, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_61);
+x_63 = l_Lean_instQuoteBool___closed__5;
+x_64 = l_Lean_Expr_isConstOf(x_61, 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; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+lean_dec(x_19);
+lean_dec(x_12);
+x_65 = l_Lean_indentExpr(x_61);
+x_66 = l_Lean_Elab_Tactic_evalDecide___rarg___lambda__2___closed__2;
+x_67 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_67, 0, x_66);
+lean_ctor_set(x_67, 1, x_65);
+x_68 = l_Lean_KernelException_toMessageData___closed__15;
+x_69 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_69, 0, x_67);
+lean_ctor_set(x_69, 1, x_68);
+x_70 = l_Lean_throwError___at_Lean_Elab_Tactic_evalTacticAux___spec__9(x_69, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_62);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_71 = lean_ctor_get(x_70, 0);
+lean_inc(x_71);
+x_72 = lean_ctor_get(x_70, 1);
+lean_inc(x_72);
+if (lean_is_exclusive(x_70)) {
+ lean_ctor_release(x_70, 0);
+ lean_ctor_release(x_70, 1);
+ x_73 = x_70;
+} else {
+ lean_dec_ref(x_70);
+ x_73 = lean_box(0);
+}
+if (lean_is_scalar(x_73)) {
+ x_74 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_74 = x_73;
+}
+lean_ctor_set(x_74, 0, x_71);
+lean_ctor_set(x_74, 1, x_72);
+return x_74;
+}
+else
+{
+lean_object* x_75; lean_object* x_76; 
+lean_dec(x_61);
+x_75 = lean_box(0);
+x_76 = l_Lean_Elab_Tactic_evalDecide___rarg___lambda__1(x_19, x_12, x_75, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_62);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_19);
-return x_75;
+return x_76;
 }
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; 
 lean_dec(x_19);
 lean_dec(x_12);
 lean_dec(x_9);
@@ -6236,32 +6246,32 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_76 = lean_ctor_get(x_59, 0);
-lean_inc(x_76);
-x_77 = lean_ctor_get(x_59, 1);
+x_77 = lean_ctor_get(x_60, 0);
 lean_inc(x_77);
-if (lean_is_exclusive(x_59)) {
- lean_ctor_release(x_59, 0);
- lean_ctor_release(x_59, 1);
- x_78 = x_59;
+x_78 = lean_ctor_get(x_60, 1);
+lean_inc(x_78);
+if (lean_is_exclusive(x_60)) {
+ lean_ctor_release(x_60, 0);
+ lean_ctor_release(x_60, 1);
+ x_79 = x_60;
 } else {
- lean_dec_ref(x_59);
- x_78 = lean_box(0);
+ lean_dec_ref(x_60);
+ x_79 = lean_box(0);
 }
-if (lean_is_scalar(x_78)) {
- x_79 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_79)) {
+ x_80 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_79 = x_78;
+ x_80 = x_79;
 }
-lean_ctor_set(x_79, 0, x_76);
-lean_ctor_set(x_79, 1, x_77);
-return x_79;
+lean_ctor_set(x_80, 0, x_77);
+lean_ctor_set(x_80, 1, x_78);
+return x_80;
 }
 }
 }
 else
 {
-uint8_t x_80; 
+uint8_t x_81; 
 lean_dec(x_12);
 lean_dec(x_9);
 lean_dec(x_8);
@@ -6269,29 +6279,29 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_80 = !lean_is_exclusive(x_17);
-if (x_80 == 0)
+x_81 = !lean_is_exclusive(x_17);
+if (x_81 == 0)
 {
 return x_17;
 }
 else
 {
-lean_object* x_81; lean_object* x_82; lean_object* x_83; 
-x_81 = lean_ctor_get(x_17, 0);
-x_82 = lean_ctor_get(x_17, 1);
+lean_object* x_82; lean_object* x_83; lean_object* x_84; 
+x_82 = lean_ctor_get(x_17, 0);
+x_83 = lean_ctor_get(x_17, 1);
+lean_inc(x_83);
 lean_inc(x_82);
-lean_inc(x_81);
 lean_dec(x_17);
-x_83 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_83, 0, x_81);
-lean_ctor_set(x_83, 1, x_82);
-return x_83;
+x_84 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_84, 0, x_82);
+lean_ctor_set(x_84, 1, x_83);
+return x_84;
 }
 }
 }
 else
 {
-uint8_t x_84; 
+uint8_t x_85; 
 lean_dec(x_12);
 lean_dec(x_9);
 lean_dec(x_8);
@@ -6299,52 +6309,52 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_84 = !lean_is_exclusive(x_14);
-if (x_84 == 0)
+x_85 = !lean_is_exclusive(x_14);
+if (x_85 == 0)
 {
 return x_14;
 }
 else
 {
-lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-x_85 = lean_ctor_get(x_14, 0);
-x_86 = lean_ctor_get(x_14, 1);
+lean_object* x_86; lean_object* x_87; lean_object* x_88; 
+x_86 = lean_ctor_get(x_14, 0);
+x_87 = lean_ctor_get(x_14, 1);
+lean_inc(x_87);
 lean_inc(x_86);
-lean_inc(x_85);
 lean_dec(x_14);
-x_87 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_87, 0, x_85);
-lean_ctor_set(x_87, 1, x_86);
-return x_87;
+x_88 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_88, 0, x_86);
+lean_ctor_set(x_88, 1, x_87);
+return x_88;
 }
 }
 }
 else
 {
-uint8_t x_88; 
+uint8_t x_89; 
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_88 = !lean_is_exclusive(x_11);
-if (x_88 == 0)
+x_89 = !lean_is_exclusive(x_11);
+if (x_89 == 0)
 {
 return x_11;
 }
 else
 {
-lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-x_89 = lean_ctor_get(x_11, 0);
-x_90 = lean_ctor_get(x_11, 1);
+lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+x_90 = lean_ctor_get(x_11, 0);
+x_91 = lean_ctor_get(x_11, 1);
+lean_inc(x_91);
 lean_inc(x_90);
-lean_inc(x_89);
 lean_dec(x_11);
-x_91 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_91, 0, x_89);
-lean_ctor_set(x_91, 1, x_90);
-return x_91;
+x_92 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_92, 0, x_90);
+lean_ctor_set(x_92, 1, x_91);
+return x_92;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Elab/Tactic/Simp.c b/stage0/stdlib/Lean/Elab/Tactic/Simp.c
index 44d5da1061..d0f9d5e141 100644
--- a/stage0/stdlib/Lean/Elab/Tactic/Simp.c
+++ b/stage0/stdlib/Lean/Elab/Tactic/Simp.c
@@ -23,7 +23,6 @@ lean_object* l___private_Lean_Elab_Tactic_Simp_0__Lean_Elab_Tactic_addSimpLemma_
 lean_object* l_Lean_Meta_simpTarget(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t l_USize_add(size_t, size_t);
 lean_object* l_Lean_Elab_Tactic_evalSimpConfigUnsafe___closed__5;
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
 lean_object* l_Lean_Elab_Term_elabCDotFunctionAlias_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_resolveGlobalConstNoOverload___at___private_Lean_Elab_Tactic_Simp_0__Lean_Elab_Tactic_elabSimpLemmas___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* l_Lean_Elab_Tactic_elabSimpConfig___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -32,6 +31,7 @@ lean_object* l_List_toString___at_Lean_resolveGlobalConstNoOverload___spec__2(le
 lean_object* l_Lean_Elab_Tactic_SavedState_restore(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_Parser_Syntax_addPrec___closed__2;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Lean_Meta_getCongrLemmas___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_Term_instMonadLogTermElabM___closed__6;
@@ -249,7 +249,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Syntax_addPrec___closed__2;
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
diff --git a/stage0/stdlib/Lean/Elab/Term.c b/stage0/stdlib/Lean/Elab/Term.c
index 2cdc55e9b9..0ce16de32a 100644
--- a/stage0/stdlib/Lean/Elab/Term.c
+++ b/stage0/stdlib/Lean/Elab/Term.c
@@ -48,13 +48,13 @@ lean_object* l_Lean_extractMacroScopes(lean_object*);
 lean_object* l_Lean_Elab_Term_synthesizeInstMVarCore___closed__8;
 lean_object* l_Lean_Elab_Term_withoutAutoBoundImplicit(lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Term_instMetaEvalTermElabM___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*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__4;
 lean_object* l_Lean_Elab_Term_MVarErrorInfo_logError___closed__6;
 lean_object* l_Lean_Elab_Term_instMonadMacroAdapterTermElabM___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_resolveNamespace___at_Lean_Elab_Term_elabOpen___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_exceptionToSorry(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t l_USize_add(size_t, size_t);
 extern lean_object* l_Lean_Name_getString_x21___closed__3;
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__4;
 lean_object* l_List_forM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__3(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_forallTelescopeReducingAuxAux___rarg(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_instMonadBacktrackSavedStateTermElabM___closed__1;
@@ -94,12 +94,12 @@ lean_object* l_Lean_Elab_pushInfoTree___at_Lean_Elab_Term_addTermInfo___spec__2_
 lean_object* l_Lean_mkSort(lean_object*);
 lean_object* l_Lean_Elab_Term_elabEnsureTypeOf_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__2;
 lean_object* l_List_foldl___at_Lean_Elab_addMacroStack___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_getLetRecsToLift___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 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_object* l_Lean_Elab_Term_instMonadInfoTreeTermElabM;
 lean_object* l_Lean_Elab_Term_elabNumLit___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__2;
 lean_object* l_Lean_Elab_Term_saveState___boxed(lean_object*);
 extern lean_object* l_Lean_withIncRecDepth___rarg___lambda__2___closed__2;
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr___spec__11___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*);
@@ -191,7 +191,6 @@ lean_object* l_Lean_Elab_Term_addTermInfo___boxed(lean_object*, lean_object*, le
 lean_object* l_Lean_Elab_Term_withoutPostponingUniverseConstraints___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_mkFreshTypeMVarFor___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_synthesizeInstMVarCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__2;
 lean_object* l_Lean_Elab_Term_registerCustomErrorIfMVar_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwUnknownConstant___at_Lean_Elab_Term_elabDoubleQuotedName___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___lambda__3___closed__1;
@@ -362,6 +361,7 @@ lean_object* l_Lean_Elab_Term_withLevelNames___rarg(lean_object*, lean_object*,
 lean_object* l_Lean_Elab_Term_withoutPostponingUniverseConstraints___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_instInhabitedTermElabM(lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_elabTypeStx(lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__1;
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabUsingElabFns_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l___private_Lean_Message_0__Lean_beqMessageSeverity____x40_Lean_Message___hyg_102_(uint8_t, uint8_t);
 lean_object* l_Lean_Elab_Term_instToStringMVarErrorKind_match__1(lean_object*);
@@ -370,7 +370,6 @@ extern lean_object* l_instReprBool___closed__2;
 lean_object* l_Lean_ScopedEnvExtension_getState___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabUsingElabFns___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_instInhabitedPersistentArray___closed__1;
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__1;
 lean_object* l_Lean_Elab_Term_elabScientificLit___closed__1;
 lean_object* l_Lean_Elab_Term_instMonadMacroAdapterTermElabM___closed__2;
 lean_object* l_Lean_Elab_Term_getMainModule___rarg(lean_object*, lean_object*);
@@ -443,10 +442,10 @@ lean_object* l_Lean_Elab_Term_instToStringMVarErrorKind___boxed(lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_decorateErrorMessageWithLambdaImplicitVars___closed__4;
 lean_object* l_List_map___at_Lean_Elab_Term_resolveId_x3f___spec__3(lean_object*);
 lean_object* l_Lean_Elab_Term_LVal_getRef___boxed(lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__1;
 lean_object* l_Lean_ScopedEnvExtension_popScope___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_instInhabitedTermElabM___closed__1;
 lean_object* l_Std_PersistentArray_forInAux___at_Lean_Elab_Term_addAutoBoundImplicits___spec__3___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__1;
 lean_object* l_Lean_Elab_Term_instMonadLogTermElabM___closed__3;
 lean_object* l_Lean_Elab_Term_instMonadQuotationTermElabM___closed__12;
 lean_object* l_Lean_Elab_Term_instToStringMVarErrorKind___closed__1;
@@ -679,12 +678,12 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabByTactic___closed__1;
 lean_object* l_Lean_Elab_Term_instMonadLogTermElabM___closed__5;
 size_t l_Lean_Name_hash(lean_object*);
 extern lean_object* l_Lean_Parser_Term_ensureTypeOf___elambda__1___closed__2;
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__2;
 lean_object* l_Lean_Elab_Term_registerSyntheticMVarWithCurrRef___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___closed__4;
 lean_object* l_Nat_repr(lean_object*);
 lean_object* l_Lean_commitWhenSome_x3f___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryPureCoe_x3f___spec__2___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryPureCoe_x3f___spec__3___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getDecLevel(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__2;
 uint8_t l_Lean_Option_get___at_Lean_ppExpr___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_elabOpen___spec__2(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addCompletionInfo___at_Lean_Elab_Term_addDotCompletionInfo___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -701,9 +700,9 @@ lean_object* l_Lean_Elab_Term_mkTypeMismatchError_match__1___rarg(lean_object*,
 lean_object* l___regBuiltin_Lean_Elab_Term_elabCharLit(lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabOptLevel___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabUsingElabFnsAux_match__2___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334_(lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983_(lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963_(lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335_(lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984_(lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964_(lean_object*);
 lean_object* l_Lean_mkAuxName___at_Lean_Elab_Term_mkAuxName___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_setElabConfig(lean_object*);
 lean_object* l_Lean_Elab_Term_instMetaEvalTermElabM___rarg___closed__4;
@@ -711,7 +710,7 @@ lean_object* l_Lean_Elab_Term_getLetRecsToLift(lean_object*);
 lean_object* l_Lean_Elab_Term_liftLevelM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Core_getMaxHeartbeats(lean_object*);
 lean_object* l_Lean_Expr_setAppPPExplicitForExposingMVars(lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_1563_(lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_1564_(lean_object*);
 extern lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1___closed__2;
 lean_object* l_Std_PersistentArray_forMAux___at_Lean_Elab_Term_instMetaEvalTermElabM___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabUsingElabFns___spec__3(lean_object*, lean_object*);
@@ -754,11 +753,11 @@ lean_object* l_Lean_MetavarContext_assignExpr(lean_object*, lean_object*, lean_o
 lean_object* lean_array_to_list(lean_object*, lean_object*);
 lean_object* lean_eval_const(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_throwAppTypeMismatch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__4;
 uint8_t l_Lean_Environment_contains(lean_object*, lean_object*);
 lean_object* l_List_filterAux___at_Lean_resolveGlobalConst___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_resolveName_match__2(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Term_synthesizeInstMVarCore___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__4;
 lean_object* l_Lean_Elab_Term_getMainModule(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_throwTypeExcepted___rarg___closed__2;
 lean_object* l_Lean_Elab_Term_isMonadApp_match__1(lean_object*);
@@ -834,7 +833,6 @@ extern lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMes
 lean_object* l_Lean_Meta_withLocalDecl___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabImplicitLambda_loop___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLCtx___at_Lean_Elab_Term_elabSyntheticHole___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ResolveName_resolveGlobalName(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1;
 lean_object* l_Lean_throwError___at_Lean_Elab_Term_mkConst___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_resolveName_process___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*, lean_object*);
 lean_object* l_ReaderT_bind___at_Lean_Elab_Term_instMonadLogTermElabM___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -894,6 +892,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabSort(lean_object*);
 extern lean_object* l_Lean_PrettyPrinter_Parenthesizer_instMonadQuotationParenthesizerM___closed__1;
 lean_object* l_Lean_Elab_Term_withAutoBoundImplicit_loop_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_tryCoeThunk_x3f_match__1___rarg___closed__1;
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1;
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___closed__2;
 lean_object* l_Lean_Elab_logAt___at_Lean_Elab_Term_elabOpen___spec__9(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_tryPostponeIfHasMVars___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1072,7 +1071,6 @@ lean_object* l_Lean_Elab_Term_liftLevelM_match__1(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_elabSort___closed__1;
 extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_16902____closed__2;
 lean_object* l_Lean_MacroScopesView_review(lean_object*);
-lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414____closed__1;
 lean_object* l_Lean_mkApp5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_synthesizeInstMVarCore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_isTypeApp_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -1097,6 +1095,7 @@ lean_object* l_Lean_Elab_Term_isLetRecAuxMVar___boxed(lean_object*, lean_object*
 lean_object* l_List_mapM___at_Lean_Elab_Term_resolveName_x27___spec__6___closed__2;
 lean_object* l_Lean_commitWhenSome_x3f___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryPureCoe_x3f___spec__2___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryPureCoe_x3f___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___closed__1;
+lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415____closed__1;
 lean_object* l_Lean_Elab_Term_elabEnsureTypeOf(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabImplicitLambda_loop___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_elabBadCDot(lean_object*);
@@ -1322,7 +1321,7 @@ lean_object* l_Lean_Elab_Term_applyResult___rarg(lean_object*, lean_object*, lea
 lean_object* l_IO_println___at_Lean_instEval___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_throwErrorIfErrors(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_NameSet_contains(lean_object*, lean_object*);
-lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414_(lean_object*);
+lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415_(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Term_evalExpr___spec__13(lean_object*);
 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*);
@@ -1369,11 +1368,11 @@ extern lean_object* l_Lean_Elab_throwAutoBoundImplicitLocal___rarg___closed__2;
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_PersistentArray_anyM___at_Lean_MessageLog_hasErrors___spec__1(lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__3;
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___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*, lean_object*);
 lean_object* l_Lean_Elab_Term_mkInstMVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_registerCustomErrorIfMVar_match__1(lean_object*);
 uint8_t l___private_Lean_Elab_Term_0__Lean_Elab_Term_isExplicitApp(lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__3;
 lean_object* l_Lean_Elab_Term_withoutPostponingUniverseConstraints_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_instMonadQuotationTermElabM___closed__5;
 extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15488____closed__3;
@@ -1384,6 +1383,7 @@ uint8_t l_List_isEmpty___rarg(lean_object*);
 lean_object* l_Lean_Elab_Term_instInhabitedSavedState;
 lean_object* l_List_lengthAux___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_instMonadQuotationTermElabM___closed__3;
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__1;
 lean_object* l_Lean_Elab_Term_hasNoImplicitLambdaAnnotation___boxed(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_elabOpen___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_Elab_Term_applyResult(lean_object*);
@@ -1407,12 +1407,12 @@ lean_object* lean_usize_to_nat(size_t);
 lean_object* l_List_foldlM___at_Lean_Elab_Term_evalExpr___spec__10(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_setMessageLog(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_level_eq(lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__3;
 lean_object* l_Lean_Message_toString(lean_object*, uint8_t, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr___spec__12___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_mkAuxName___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkAppB(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MetavarContext_findUserName_x3f(lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__3;
 lean_object* l_Lean_Elab_addMacroStack___at_Lean_Elab_Term_instAddErrorMessageContextTermElabM___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabCompletion(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_pushInfoLeaf___at_Lean_Elab_Term_addTermInfo___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1559,26 +1559,28 @@ return x_1;
 }
 else
 {
-uint8_t x_5; uint8_t x_6; uint8_t x_7; uint8_t x_8; uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
+uint8_t x_5; uint8_t x_6; uint8_t x_7; uint8_t x_8; uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
 x_5 = lean_ctor_get_uint8(x_1, 4);
 x_6 = lean_ctor_get_uint8(x_1, 5);
 x_7 = lean_ctor_get_uint8(x_1, 6);
 x_8 = lean_ctor_get_uint8(x_1, 7);
 x_9 = lean_ctor_get_uint8(x_1, 8);
+x_10 = lean_ctor_get_uint8(x_1, 9);
 lean_dec(x_1);
-x_10 = 1;
-x_11 = 0;
-x_12 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_12, 0, x_10);
-lean_ctor_set_uint8(x_12, 1, x_10);
-lean_ctor_set_uint8(x_12, 2, x_11);
-lean_ctor_set_uint8(x_12, 3, x_11);
-lean_ctor_set_uint8(x_12, 4, x_5);
-lean_ctor_set_uint8(x_12, 5, x_6);
-lean_ctor_set_uint8(x_12, 6, x_7);
-lean_ctor_set_uint8(x_12, 7, x_8);
-lean_ctor_set_uint8(x_12, 8, x_9);
-return x_12;
+x_11 = 1;
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_13, 0, x_11);
+lean_ctor_set_uint8(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, 2, x_12);
+lean_ctor_set_uint8(x_13, 3, x_12);
+lean_ctor_set_uint8(x_13, 4, x_5);
+lean_ctor_set_uint8(x_13, 5, x_6);
+lean_ctor_set_uint8(x_13, 6, x_7);
+lean_ctor_set_uint8(x_13, 7, x_8);
+lean_ctor_set_uint8(x_13, 8, x_9);
+lean_ctor_set_uint8(x_13, 9, x_10);
+return x_13;
 }
 }
 }
@@ -5325,7 +5327,7 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_1563_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_1564_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -12633,7 +12635,7 @@ lean_dec(x_4);
 return x_10;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__1() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -12641,17 +12643,17 @@ x_1 = lean_mk_string("autoLift");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__2() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__1;
+x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__3() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -12659,13 +12661,13 @@ x_1 = lean_mk_string("insert monadic lifts (i.e., `liftM` and `liftCoeM`) when n
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__4() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____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_instInhabitedParserDescr___closed__1;
-x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__3;
+x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__3;
 x_4 = lean_box(x_1);
 x_5 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_5, 0, x_4);
@@ -12674,17 +12676,17 @@ lean_ctor_set(x_5, 2, x_3);
 return x_5;
 }
 }
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__2;
-x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__4;
+x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__2;
+x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__4;
 x_4 = l_Lean_Option_register___at_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_4____spec__1(x_2, x_3, x_1);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__1() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -12692,17 +12694,17 @@ x_1 = lean_mk_string("maxCoeSize");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__2() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__1;
+x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__3() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -12710,13 +12712,13 @@ x_1 = lean_mk_string("maximum number of instances used to construct an automatic
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__4() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = lean_unsigned_to_nat(16u);
 x_2 = l_Lean_instInhabitedParserDescr___closed__1;
-x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__3;
+x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__3;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -12724,12 +12726,12 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__2;
-x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__4;
+x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__2;
+x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__4;
 x_4 = l_Lean_Option_register___at_Lean_initFn____x40_Lean_Util_RecDepth___hyg_4____spec__1(x_2, x_3, x_1);
 return x_4;
 }
@@ -13955,7 +13957,7 @@ return x_51;
 }
 else
 {
-uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; uint8_t x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; uint8_t x_59; uint8_t x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
 x_52 = lean_ctor_get_uint8(x_9, 0);
 x_53 = lean_ctor_get_uint8(x_9, 1);
 x_54 = lean_ctor_get_uint8(x_9, 2);
@@ -13964,198 +13966,200 @@ x_56 = lean_ctor_get_uint8(x_9, 4);
 x_57 = lean_ctor_get_uint8(x_9, 6);
 x_58 = lean_ctor_get_uint8(x_9, 7);
 x_59 = lean_ctor_get_uint8(x_9, 8);
+x_60 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_60 = 2;
-x_61 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_61, 0, x_52);
-lean_ctor_set_uint8(x_61, 1, x_53);
-lean_ctor_set_uint8(x_61, 2, x_54);
-lean_ctor_set_uint8(x_61, 3, x_55);
-lean_ctor_set_uint8(x_61, 4, x_56);
-lean_ctor_set_uint8(x_61, 5, x_60);
-lean_ctor_set_uint8(x_61, 6, x_57);
-lean_ctor_set_uint8(x_61, 7, x_58);
-lean_ctor_set_uint8(x_61, 8, x_59);
-x_62 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_62, 0, x_61);
-lean_ctor_set(x_62, 1, x_10);
-lean_ctor_set(x_62, 2, x_11);
-lean_ctor_set(x_62, 3, x_12);
+x_61 = 2;
+x_62 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_62, 0, x_52);
+lean_ctor_set_uint8(x_62, 1, x_53);
+lean_ctor_set_uint8(x_62, 2, x_54);
+lean_ctor_set_uint8(x_62, 3, x_55);
+lean_ctor_set_uint8(x_62, 4, x_56);
+lean_ctor_set_uint8(x_62, 5, x_61);
+lean_ctor_set_uint8(x_62, 6, x_57);
+lean_ctor_set_uint8(x_62, 7, x_58);
+lean_ctor_set_uint8(x_62, 8, x_59);
+lean_ctor_set_uint8(x_62, 9, x_60);
+x_63 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_63, 0, x_62);
+lean_ctor_set(x_63, 1, x_10);
+lean_ctor_set(x_63, 2, x_11);
+lean_ctor_set(x_63, 3, x_12);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-x_63 = l_Lean_Meta_whnf(x_1, x_62, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_63) == 0)
+x_64 = l_Lean_Meta_whnf(x_1, x_63, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_64) == 0)
 {
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_63, 0);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 5)
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_65 = lean_ctor_get(x_63, 1);
+lean_object* x_65; 
+x_65 = lean_ctor_get(x_64, 0);
 lean_inc(x_65);
-lean_dec(x_63);
-x_66 = lean_ctor_get(x_64, 0);
+if (lean_obj_tag(x_65) == 5)
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_66 = lean_ctor_get(x_64, 1);
 lean_inc(x_66);
-x_67 = lean_ctor_get(x_64, 1);
-lean_inc(x_67);
 lean_dec(x_64);
+x_67 = lean_ctor_get(x_65, 0);
+lean_inc(x_67);
+x_68 = lean_ctor_get(x_65, 1);
+lean_inc(x_68);
+lean_dec(x_65);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_68 = l_Lean_Meta_instantiateMVars(x_66, x_4, x_5, x_6, x_7, x_65);
-if (lean_obj_tag(x_68) == 0)
+x_69 = l_Lean_Meta_instantiateMVars(x_67, x_4, x_5, x_6, x_7, x_66);
+if (lean_obj_tag(x_69) == 0)
 {
-lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-x_69 = lean_ctor_get(x_68, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_68, 1);
+lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_70 = lean_ctor_get(x_69, 0);
 lean_inc(x_70);
-lean_dec(x_68);
-x_71 = l_Lean_Meta_instantiateMVars(x_67, x_4, x_5, x_6, x_7, x_70);
-if (lean_obj_tag(x_71) == 0)
-{
-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_71, 0);
-lean_inc(x_72);
-x_73 = lean_ctor_get(x_71, 1);
-lean_inc(x_73);
-if (lean_is_exclusive(x_71)) {
- lean_ctor_release(x_71, 0);
- lean_ctor_release(x_71, 1);
- x_74 = x_71;
-} else {
- lean_dec_ref(x_71);
- x_74 = lean_box(0);
-}
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_69);
-lean_ctor_set(x_75, 1, x_72);
-x_76 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_76, 0, x_75);
-if (lean_is_scalar(x_74)) {
- x_77 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_77 = x_74;
-}
-lean_ctor_set(x_77, 0, x_76);
-lean_ctor_set(x_77, 1, x_73);
-return x_77;
-}
-else
-{
-lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
+x_71 = lean_ctor_get(x_69, 1);
+lean_inc(x_71);
 lean_dec(x_69);
-x_78 = lean_ctor_get(x_71, 0);
-lean_inc(x_78);
-x_79 = lean_ctor_get(x_71, 1);
+x_72 = l_Lean_Meta_instantiateMVars(x_68, x_4, x_5, x_6, x_7, x_71);
+if (lean_obj_tag(x_72) == 0)
+{
+lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+x_73 = lean_ctor_get(x_72, 0);
+lean_inc(x_73);
+x_74 = lean_ctor_get(x_72, 1);
+lean_inc(x_74);
+if (lean_is_exclusive(x_72)) {
+ lean_ctor_release(x_72, 0);
+ lean_ctor_release(x_72, 1);
+ x_75 = x_72;
+} else {
+ lean_dec_ref(x_72);
+ x_75 = lean_box(0);
+}
+x_76 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_76, 0, x_70);
+lean_ctor_set(x_76, 1, x_73);
+x_77 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_77, 0, x_76);
+if (lean_is_scalar(x_75)) {
+ x_78 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_78 = x_75;
+}
+lean_ctor_set(x_78, 0, x_77);
+lean_ctor_set(x_78, 1, x_74);
+return x_78;
+}
+else
+{
+lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; 
+lean_dec(x_70);
+x_79 = lean_ctor_get(x_72, 0);
 lean_inc(x_79);
-if (lean_is_exclusive(x_71)) {
- lean_ctor_release(x_71, 0);
- lean_ctor_release(x_71, 1);
- x_80 = x_71;
+x_80 = lean_ctor_get(x_72, 1);
+lean_inc(x_80);
+if (lean_is_exclusive(x_72)) {
+ lean_ctor_release(x_72, 0);
+ lean_ctor_release(x_72, 1);
+ x_81 = x_72;
 } else {
- lean_dec_ref(x_71);
- x_80 = lean_box(0);
+ lean_dec_ref(x_72);
+ x_81 = lean_box(0);
 }
-if (lean_is_scalar(x_80)) {
- x_81 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_81)) {
+ x_82 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_81 = x_80;
+ x_82 = x_81;
 }
-lean_ctor_set(x_81, 0, x_78);
-lean_ctor_set(x_81, 1, x_79);
-return x_81;
+lean_ctor_set(x_82, 0, x_79);
+lean_ctor_set(x_82, 1, x_80);
+return x_82;
 }
 }
 else
 {
-lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-lean_dec(x_67);
+lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+lean_dec(x_68);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_82 = lean_ctor_get(x_68, 0);
-lean_inc(x_82);
-x_83 = lean_ctor_get(x_68, 1);
+x_83 = lean_ctor_get(x_69, 0);
 lean_inc(x_83);
-if (lean_is_exclusive(x_68)) {
- lean_ctor_release(x_68, 0);
- lean_ctor_release(x_68, 1);
- x_84 = x_68;
+x_84 = lean_ctor_get(x_69, 1);
+lean_inc(x_84);
+if (lean_is_exclusive(x_69)) {
+ lean_ctor_release(x_69, 0);
+ lean_ctor_release(x_69, 1);
+ x_85 = x_69;
 } else {
- lean_dec_ref(x_68);
- x_84 = lean_box(0);
+ lean_dec_ref(x_69);
+ x_85 = lean_box(0);
 }
-if (lean_is_scalar(x_84)) {
- x_85 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_85)) {
+ x_86 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_85 = x_84;
+ x_86 = x_85;
 }
-lean_ctor_set(x_85, 0, x_82);
-lean_ctor_set(x_85, 1, x_83);
-return x_85;
+lean_ctor_set(x_86, 0, x_83);
+lean_ctor_set(x_86, 1, x_84);
+return x_86;
 }
 }
 else
 {
-lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
-lean_dec(x_64);
+lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
+lean_dec(x_65);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_86 = lean_ctor_get(x_63, 1);
-lean_inc(x_86);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- lean_ctor_release(x_63, 1);
- x_87 = x_63;
+x_87 = lean_ctor_get(x_64, 1);
+lean_inc(x_87);
+if (lean_is_exclusive(x_64)) {
+ lean_ctor_release(x_64, 0);
+ lean_ctor_release(x_64, 1);
+ x_88 = x_64;
 } else {
- lean_dec_ref(x_63);
- x_87 = lean_box(0);
+ lean_dec_ref(x_64);
+ x_88 = lean_box(0);
 }
-x_88 = lean_box(0);
-if (lean_is_scalar(x_87)) {
- x_89 = lean_alloc_ctor(0, 2, 0);
+x_89 = lean_box(0);
+if (lean_is_scalar(x_88)) {
+ x_90 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_89 = x_87;
+ x_90 = x_88;
 }
-lean_ctor_set(x_89, 0, x_88);
-lean_ctor_set(x_89, 1, x_86);
-return x_89;
+lean_ctor_set(x_90, 0, x_89);
+lean_ctor_set(x_90, 1, x_87);
+return x_90;
 }
 }
 else
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; 
+lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_90 = lean_ctor_get(x_63, 0);
-lean_inc(x_90);
-x_91 = lean_ctor_get(x_63, 1);
+x_91 = lean_ctor_get(x_64, 0);
 lean_inc(x_91);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- lean_ctor_release(x_63, 1);
- x_92 = x_63;
+x_92 = lean_ctor_get(x_64, 1);
+lean_inc(x_92);
+if (lean_is_exclusive(x_64)) {
+ lean_ctor_release(x_64, 0);
+ lean_ctor_release(x_64, 1);
+ x_93 = x_64;
 } else {
- lean_dec_ref(x_63);
- x_92 = lean_box(0);
+ lean_dec_ref(x_64);
+ x_93 = lean_box(0);
 }
-if (lean_is_scalar(x_92)) {
- x_93 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_93)) {
+ x_94 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_93 = x_92;
+ x_94 = x_93;
 }
-lean_ctor_set(x_93, 0, x_90);
-lean_ctor_set(x_93, 1, x_91);
-return x_93;
+lean_ctor_set(x_94, 0, x_91);
+lean_ctor_set(x_94, 1, x_92);
+return x_94;
 }
 }
 }
@@ -33134,7 +33138,7 @@ lean_dec(x_3);
 return x_9;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1() {
+static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -33144,11 +33148,11 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1;
+x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1;
 x_3 = l_Lean_registerTraceClass(x_2, x_1);
 return x_3;
 }
@@ -33319,7 +33323,7 @@ lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lea
 x_97 = lean_ctor_get(x_91, 1);
 lean_inc(x_97);
 lean_dec(x_91);
-x_98 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1;
+x_98 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1;
 x_99 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_98, x_2, x_3, x_4, x_5, x_6, x_7, x_97);
 x_100 = lean_ctor_get(x_99, 0);
 lean_inc(x_100);
@@ -33361,7 +33365,7 @@ lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean
 x_53 = lean_ctor_get(x_47, 1);
 lean_inc(x_53);
 lean_dec(x_47);
-x_54 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1;
+x_54 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1;
 x_55 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_54, x_2, x_3, x_4, x_5, x_6, x_7, x_53);
 x_56 = lean_ctor_get(x_55, 0);
 lean_inc(x_56);
@@ -33442,7 +33446,7 @@ x_41 = l_Lean_KernelException_toMessageData___closed__15;
 x_42 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_42, 0, x_40);
 lean_ctor_set(x_42, 1, x_41);
-x_43 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1;
+x_43 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1;
 x_44 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_43, x_42, x_2, x_3, x_4, x_5, x_6, x_7, x_36);
 x_45 = lean_ctor_get(x_44, 1);
 lean_inc(x_45);
@@ -33504,7 +33508,7 @@ x_79 = l_Lean_KernelException_toMessageData___closed__15;
 x_80 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_80, 0, x_78);
 lean_ctor_set(x_80, 1, x_79);
-x_81 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1;
+x_81 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1;
 x_82 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_81, x_80, x_2, x_3, x_4, x_5, x_6, x_7, x_61);
 x_83 = lean_ctor_get(x_82, 1);
 lean_inc(x_83);
@@ -33833,7 +33837,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_2 = l_Lean_Elab_Term_termElabAttribute;
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_4 = l___regBuiltin_Lean_Elab_Term_elabTypeStx___closed__1;
 x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1);
 return x_5;
@@ -50199,58 +50203,77 @@ x_14 = lean_compile_decl(x_12, x_13, x_1);
 lean_dec(x_13);
 if (lean_obj_tag(x_14) == 0)
 {
-lean_object* x_15; lean_object* x_16; 
+lean_object* x_15; 
 x_15 = lean_ctor_get(x_14, 0);
 lean_inc(x_15);
 lean_dec(x_14);
-lean_inc(x_2);
-x_16 = l___private_Lean_MonadEnv_0__Lean_checkUnsupported___at_Lean_Elab_Term_evalExpr___spec__6(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_11);
-if (lean_obj_tag(x_16) == 0)
+if (lean_obj_tag(x_15) == 11)
 {
-lean_object* x_17; lean_object* x_18; 
-x_17 = lean_ctor_get(x_16, 1);
-lean_inc(x_17);
-lean_dec(x_16);
-x_18 = l_Lean_throwKernelException___at_Lean_Elab_Term_evalExpr___spec__4(x_15, x_2, x_3, x_4, x_5, x_6, x_7, x_17);
-return x_18;
-}
-else
-{
-uint8_t x_19; 
+lean_object* x_16; lean_object* x_17; 
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
 lean_dec(x_15);
-lean_dec(x_6);
-lean_dec(x_2);
-x_19 = !lean_is_exclusive(x_16);
-if (x_19 == 0)
+lean_inc(x_2);
+x_17 = l___private_Lean_MonadEnv_0__Lean_checkUnsupported___at_Lean_Elab_Term_evalExpr___spec__6(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_11);
+if (lean_obj_tag(x_17) == 0)
 {
-return x_16;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = lean_ctor_get(x_17, 1);
+lean_inc(x_18);
+lean_dec(x_17);
+x_19 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_19, 0, x_16);
+x_20 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_20, 0, x_19);
+x_21 = l_Lean_throwError___at_Lean_Elab_Term_throwErrorIfErrors___spec__1(x_20, x_2, x_3, x_4, x_5, x_6, x_7, x_18);
+lean_dec(x_6);
+return x_21;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_20 = lean_ctor_get(x_16, 0);
-x_21 = lean_ctor_get(x_16, 1);
-lean_inc(x_21);
-lean_inc(x_20);
+uint8_t x_22; 
 lean_dec(x_16);
-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_6);
+lean_dec(x_2);
+x_22 = !lean_is_exclusive(x_17);
+if (x_22 == 0)
+{
+return x_17;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_23 = lean_ctor_get(x_17, 0);
+x_24 = lean_ctor_get(x_17, 1);
+lean_inc(x_24);
+lean_inc(x_23);
+lean_dec(x_17);
+x_25 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_25, 0, x_23);
+lean_ctor_set(x_25, 1, x_24);
+return x_25;
 }
 }
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
+lean_object* x_26; 
 lean_dec(x_1);
-x_23 = lean_ctor_get(x_14, 0);
-lean_inc(x_23);
+x_26 = l_Lean_throwKernelException___at_Lean_Elab_Term_evalExpr___spec__4(x_15, x_2, x_3, x_4, x_5, x_6, x_7, x_11);
+return x_26;
+}
+}
+else
+{
+lean_object* x_27; lean_object* x_28; 
+lean_dec(x_1);
+x_27 = lean_ctor_get(x_14, 0);
+lean_inc(x_27);
 lean_dec(x_14);
-x_24 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__1(x_23, x_2, x_3, x_4, x_5, x_6, x_7, x_11);
+x_28 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__1(x_27, x_2, x_3, x_4, x_5, x_6, x_7, x_11);
 lean_dec(x_6);
 lean_dec(x_2);
-return x_24;
+return x_28;
 }
 }
 }
@@ -53187,7 +53210,7 @@ lean_dec(x_3);
 return x_11;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414____closed__1() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415____closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -53197,7 +53220,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414_(lean_object* x_1) {
+lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -53209,7 +53232,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_13414____closed__1;
+x_5 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415____closed__1;
 x_6 = l_Lean_registerTraceClass(x_5, x_4);
 if (lean_obj_tag(x_6) == 0)
 {
@@ -53495,7 +53518,7 @@ l_Lean_Elab_Term_mkTermElabAttributeUnsafe___closed__8 = _init_l_Lean_Elab_Term_
 lean_mark_persistent(l_Lean_Elab_Term_mkTermElabAttributeUnsafe___closed__8);
 l_Lean_Elab_Term_mkTermElabAttributeUnsafe___closed__9 = _init_l_Lean_Elab_Term_mkTermElabAttributeUnsafe___closed__9();
 lean_mark_persistent(l_Lean_Elab_Term_mkTermElabAttributeUnsafe___closed__9);
-res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_1563_(lean_io_mk_world());
+res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_1564_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Elab_Term_termElabAttribute = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Elab_Term_termElabAttribute);
@@ -53568,28 +53591,28 @@ l_Lean_Elab_Term_synthesizeInstMVarCore___closed__7 = _init_l_Lean_Elab_Term_syn
 lean_mark_persistent(l_Lean_Elab_Term_synthesizeInstMVarCore___closed__7);
 l_Lean_Elab_Term_synthesizeInstMVarCore___closed__8 = _init_l_Lean_Elab_Term_synthesizeInstMVarCore___closed__8();
 lean_mark_persistent(l_Lean_Elab_Term_synthesizeInstMVarCore___closed__8);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__1();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__1);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__2();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__2);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__3();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__3);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__4();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963____closed__4);
-res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3963_(lean_io_mk_world());
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__1();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__1);
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__2();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__2);
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__3();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__3);
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__4();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964____closed__4);
+res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3964_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Elab_Term_autoLift = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Elab_Term_autoLift);
 lean_dec_ref(res);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__1();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__1);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__2();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__2);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__3();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__3);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__4();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983____closed__4);
-res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3983_(lean_io_mk_world());
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__1();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__1);
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__2();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__2);
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__3();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__3);
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__4();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984____closed__4);
+res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_3984_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Elab_Term_maxCoeSize = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Elab_Term_maxCoeSize);
@@ -53690,9 +53713,9 @@ l_Lean_Elab_Term_mkAuxName___closed__1 = _init_l_Lean_Elab_Term_mkAuxName___clos
 lean_mark_persistent(l_Lean_Elab_Term_mkAuxName___closed__1);
 l_Lean_Elab_Term_mkAuxName___closed__2 = _init_l_Lean_Elab_Term_mkAuxName___closed__2();
 lean_mark_persistent(l_Lean_Elab_Term_mkAuxName___closed__2);
-l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1();
-lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334____closed__1);
-res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9334_(lean_io_mk_world());
+l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1();
+lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335____closed__1);
+res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_9335_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 l_Lean_Elab_Term_isLetRecAuxMVar___closed__1 = _init_l_Lean_Elab_Term_isLetRecAuxMVar___closed__1();
@@ -53919,9 +53942,9 @@ l___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr___closed_
 lean_mark_persistent(l___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr___closed__3);
 l___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr___closed__4 = _init_l___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr___closed__4();
 lean_mark_persistent(l___private_Lean_Elab_Term_0__Lean_Elab_Term_throwStuckAtUniverseCnstr___closed__4);
-l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414____closed__1();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414____closed__1);
-res = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13414_(lean_io_mk_world());
+l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415____closed__1();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415____closed__1);
+res = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_13415_(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));
diff --git a/stage0/stdlib/Lean/Environment.c b/stage0/stdlib/Lean/Environment.c
index 804e96cb64..1e5c01c653 100644
--- a/stage0/stdlib/Lean/Environment.c
+++ b/stage0/stdlib/Lean/Environment.c
@@ -41,7 +41,6 @@ lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_instInhabitedEnvExtensionInterface___closed__2;
 uint8_t l_Lean_EnvironmentHeader_quotInit___default;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__5___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__1(lean_object*, lean_object*);
 lean_object* lean_nat_div(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_displayStats___closed__6;
 lean_object* l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(lean_object*, lean_object*, lean_object*);
@@ -50,6 +49,7 @@ lean_object* l_Std_AssocList_find_x3f___at_Lean_Environment_find_x3f___spec__6__
 lean_object* lean_display_stats(lean_object*, lean_object*);
 uint8_t l_Array_anyMUnsafe_any___at_Lean_registerPersistentEnvExtensionUnsafe___spec__1___rarg(lean_object*, lean_object*, size_t, size_t);
 lean_object* l_Lean_Environment_isConstructor_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_withImportModules(lean_object*);
 uint8_t l_Lean_Environment_isNamespace(lean_object*, lean_object*);
 lean_object* l_Lean_instInhabitedEnvironmentHeader;
@@ -107,18 +107,18 @@ lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Environment_0__Lean_se
 extern lean_object* l_Array_empty___closed__1;
 lean_object* l_Lean_registerSimplePersistentEnvExtension_match__1___rarg(lean_object*, lean_object*);
 lean_object* lean_environment_find(lean_object*, lean_object*);
-lean_object* l_IO_fileExists___at_Lean_importModules_importMods___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Environment_evalConstCheck_match__1(lean_object*);
 lean_object* l_Lean_instInhabitedEnvironment___closed__4;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l_Monad_seqRight___default___rarg___lambda__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__2;
 lean_object* lean_read_module_data(lean_object*, lean_object*);
 lean_object* l_Lean_Name_quickLt___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__3___rarg___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedParserDescr___closed__1;
 uint8_t lean_name_eq(lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__2;
 lean_object* l_Array_qpartition_loop___at_Lean_mkMapDeclarationExtension___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Environment_0__Lean_finalizePersistentExtensions(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_ConstantInfo_isUnsafe(lean_object*);
 lean_object* l_Lean_mkTagDeclarationExtension___closed__2;
@@ -148,10 +148,11 @@ lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Environment_freeRegions___spec_
 lean_object* l_Lean_Environment_evalConst___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_binSearchAux___at_Lean_MapDeclarationExtension_find_x3f___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtension___rarg(lean_object*);
-lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__3;
 lean_object* l_Lean_PersistentEnvExtension_setState___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__3;
 lean_object* l_Std_PersistentHashMap_insertAux___at_Lean_Environment_addAux___spec__3(lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceImp___elambda__4___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_mkMapDeclarationExtension___rarg___lambda__3(lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtension_modifyState(lean_object*);
 lean_object* l_Lean_importModules___lambda__3(lean_object*, uint32_t, lean_object*, lean_object*, lean_object*);
@@ -171,10 +172,10 @@ lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__4(lean
 lean_object* l_Std_PersistentHashMap_findAtAux___at_Lean_Environment_find_x3f___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 uint8_t l_Lean_NameMap_contains___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__5;
 lean_object* l_Lean_SimplePersistentEnvExtension_modifyState(lean_object*, lean_object*);
 lean_object* l_Std_AssocList_contains___at_Lean_importModules___spec__3___boxed(lean_object*, lean_object*);
 lean_object* l_Nat_foldAux___at_Lean_mkModuleData___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__5;
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Environment_displayStats___spec__8___lambda__1___closed__3;
 lean_object* l_Lean_findOLean(lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Lean_registerSimplePersistentEnvExtension___spec__2(lean_object*, lean_object*);
@@ -190,9 +191,10 @@ uint8_t l_Array_binSearchAux___at_Lean_MapDeclarationExtension_contains___spec__
 lean_object* l_Lean_Environment_contains___boxed(lean_object*, lean_object*);
 lean_object* l_Array_qpartition_loop___at_Lean_mkMapDeclarationExtension___spec__3(lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Environment_displayStats___spec__8___closed__2;
-lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__1;
+lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__1;
 lean_object* l_Lean_TagDeclarationExtension_isTagged_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Environment_0__Lean_setImportedEntries___spec__2(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*);
+lean_object* l_System_FilePath_pathExists(lean_object*, lean_object*);
 lean_object* l_Lean_importModules_importMods_match__1(lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Environment_displayStats___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceImp___closed__4;
@@ -215,11 +217,11 @@ lean_object* l_Lean_importModules_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_MapDeclarationExtension_find_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Environment_displayStats___closed__5;
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_mkModuleData___spec__2___boxed(lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__3(lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_registerSimplePersistentEnvExtension___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Environment_0__Lean_Environment_registerNamePrefixes_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_Environment_find_x3f___spec__2(lean_object*, lean_object*);
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__3(lean_object*, size_t, size_t, lean_object*);
 lean_object* lean_write_module(lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_binSearchAux___at_Lean_TagDeclarationExtension_isTagged___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SimplePersistentEnvExtension_getEntries(lean_object*, lean_object*);
@@ -289,7 +291,6 @@ lean_object* l_Lean_namespacesExt___elambda__1(lean_object*);
 lean_object* l_Lean_ConstantInfo_name(lean_object*);
 extern lean_object* l___private_Init_Data_Repr_0__reprSourceInfo____x40_Init_Data_Repr___hyg_1438____closed__4;
 uint8_t l_Lean_Name_quickCmp(lean_object*, lean_object*);
-lean_object* l_IO_fileExists___at_Lean_importModules_importMods___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkMapDeclarationExtension___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_TagDeclarationExtension_isTagged_match__1(lean_object*);
 uint8_t l___private_Lean_Environment_0__Lean_Environment_isNamespaceName(lean_object*);
@@ -366,6 +367,7 @@ lean_object* l_Lean_MapDeclarationExtension_instInhabitedMapDeclarationExtension
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_namespacesExt___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_mkEmptyEnvironment___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkEmptyEnvironment___lambda__1___closed__1;
 lean_object* l_Lean_PersistentEnvExtension_modifyState(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_PersistentHashMap_contains___at_Lean_Environment_contains___spec__3(lean_object*, lean_object*);
@@ -373,9 +375,9 @@ lean_object* l_Lean_PersistentEnvExtensionDescr_statsFn___default___boxed(lean_o
 lean_object* l_Lean_instInhabitedEnvironmentHeader___closed__1;
 lean_object* l_Lean_PersistentEnvExtension_getState___rarg___boxed(lean_object*, lean_object*);
 size_t l_USize_mul(size_t, size_t);
+lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_object* l_Lean_registerEnvExtension(lean_object*);
 lean_object* l_Lean_importModules___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
 lean_object* l_Lean_PersistentEnvExtension_getState(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionEntrySpec;
 lean_object* l_Lean_importModules___closed__1;
@@ -389,7 +391,6 @@ lean_object* l_Lean_CompactedRegion_free___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_instInhabitedEnvExtensionInterface;
 extern uint32_t l_instInhabitedUInt32___closed__1;
 lean_object* l_Lean_EnvExtensionInterfaceImp___closed__6;
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_TagDeclarationExtension_instInhabitedTagDeclarationExtension___closed__1;
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_importModules_importMods_match__2___rarg(lean_object*, lean_object*, lean_object*);
@@ -438,7 +439,6 @@ lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Environment_0__Lean_se
 lean_object* l_Lean_PersistentEnvExtension_modifyState___rarg___lambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_FindImpl_initCache;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_setState___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* lean_io_file_exists(lean_object*, lean_object*);
 lean_object* lean_mk_empty_environment(uint32_t, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAtCollisionNodeAux___at_Lean_Environment_addAux___spec__5(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -526,7 +526,7 @@ lean_object* l_Lean_Environment_header___default___closed__1;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_getState___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtensionDescr_statsFn___default(lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630_(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629_(lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_1597_(lean_object*);
 lean_object* l_Lean_instInhabitedPersistentEnvExtensionState___rarg(lean_object*);
 lean_object* l___private_Lean_Environment_0__Lean_getEntriesFor___closed__1;
@@ -552,7 +552,6 @@ lean_object* l_Std_RBNode_find___at_Lean_MapDeclarationExtension_find_x3f___spec
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_imp___closed__7;
 lean_object* l_Lean_Environment_allImportedModuleNames(lean_object*);
 lean_object* l_Lean_Environment_hasUnsafe_match__1(lean_object*);
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_addAux(lean_object*, lean_object*);
 uint8_t l_Lean_MapDeclarationExtension_contains___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux_traverse___at_Lean_mkModuleData___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -601,8 +600,8 @@ lean_object* l_Lean_Environment_imports___boxed(lean_object*);
 lean_object* l_Lean_EnvExtension_setState___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_namespacesExt;
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_mkModuleData___spec__4(lean_object*, size_t, size_t, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2(lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_EnvExtensionInterfaceUnsafe_mkInitialExtStates___spec__1(size_t, size_t, lean_object*, lean_object*);
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2(lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Lean_importModules_match__1(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Environment_0__Lean_finalizePersistentExtensions___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_namespacesExt___closed__4;
@@ -666,7 +665,6 @@ extern lean_object* l_term_x5b___x5d___closed__3;
 lean_object* l_Array_qpartition_loop___at_Lean_mkMapDeclarationExtension___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Environment_0__Lean_Environment_registerNamePrefixes_match__1(lean_object*);
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_qsort_sort___at_Lean_mkMapDeclarationExtension___spec__1___rarg___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* lean_add_decl(lean_object*, lean_object*);
@@ -9240,14 +9238,6 @@ x_2 = lean_alloc_closure((void*)(l_Lean_importModules_match__3___rarg), 2, 0);
 return x_2;
 }
 }
-lean_object* l_IO_fileExists___at_Lean_importModules_importMods___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_io_file_exists(x_1, x_3);
-return x_4;
-}
-}
 lean_object* l_Lean_importModules_importMods___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
@@ -9470,16 +9460,13 @@ lean_dec(x_22);
 x_24 = l_Lean_findOLean(x_13, x_23);
 if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; 
 x_25 = lean_ctor_get(x_24, 0);
 lean_inc(x_25);
 x_26 = lean_ctor_get(x_24, 1);
 lean_inc(x_26);
 lean_dec(x_24);
-x_27 = lean_io_file_exists(x_25, x_26);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; uint8_t x_29; 
+x_27 = l_System_FilePath_pathExists(x_25, x_26);
 x_28 = lean_ctor_get(x_27, 0);
 lean_inc(x_28);
 x_29 = lean_unbox(x_28);
@@ -9550,22 +9537,21 @@ return x_55;
 else
 {
 uint8_t x_56; 
-lean_dec(x_25);
 lean_dec(x_13);
 lean_dec(x_7);
-x_56 = !lean_is_exclusive(x_27);
+x_56 = !lean_is_exclusive(x_24);
 if (x_56 == 0)
 {
-return x_27;
+return x_24;
 }
 else
 {
 lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_57 = lean_ctor_get(x_27, 0);
-x_58 = lean_ctor_get(x_27, 1);
+x_57 = lean_ctor_get(x_24, 0);
+x_58 = lean_ctor_get(x_24, 1);
 lean_inc(x_58);
 lean_inc(x_57);
-lean_dec(x_27);
+lean_dec(x_24);
 x_59 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_59, 0, x_57);
 lean_ctor_set(x_59, 1, x_58);
@@ -9575,173 +9561,117 @@ return x_59;
 }
 else
 {
-uint8_t x_60; 
-lean_dec(x_13);
-lean_dec(x_7);
-x_60 = !lean_is_exclusive(x_24);
-if (x_60 == 0)
-{
-return x_24;
-}
-else
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_24, 0);
-x_62 = lean_ctor_get(x_24, 1);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_60 = lean_ctor_get(x_16, 0);
+x_61 = lean_ctor_get(x_16, 1);
+x_62 = lean_ctor_get(x_16, 2);
+x_63 = lean_ctor_get(x_16, 3);
+lean_inc(x_63);
 lean_inc(x_62);
 lean_inc(x_61);
-lean_dec(x_24);
-x_63 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_63, 0, x_61);
-lean_ctor_set(x_63, 1, x_62);
-return x_63;
-}
-}
-}
-else
-{
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_64 = lean_ctor_get(x_16, 0);
-x_65 = lean_ctor_get(x_16, 1);
-x_66 = lean_ctor_get(x_16, 2);
-x_67 = lean_ctor_get(x_16, 3);
-lean_inc(x_67);
-lean_inc(x_66);
-lean_inc(x_65);
-lean_inc(x_64);
+lean_inc(x_60);
 lean_dec(x_16);
-x_68 = lean_box(0);
+x_64 = lean_box(0);
 lean_inc(x_13);
-x_69 = l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(x_64, x_13, x_68);
-x_70 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_70, 1, x_65);
-lean_ctor_set(x_70, 2, x_66);
-lean_ctor_set(x_70, 3, x_67);
-x_71 = lean_st_ref_set(x_2, x_70, x_17);
-x_72 = lean_ctor_get(x_71, 1);
-lean_inc(x_72);
-lean_dec(x_71);
-x_73 = l_Lean_findOLean(x_13, x_72);
-if (lean_obj_tag(x_73) == 0)
+x_65 = l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(x_60, x_13, x_64);
+x_66 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_66, 0, x_65);
+lean_ctor_set(x_66, 1, x_61);
+lean_ctor_set(x_66, 2, x_62);
+lean_ctor_set(x_66, 3, x_63);
+x_67 = lean_st_ref_set(x_2, x_66, x_17);
+x_68 = lean_ctor_get(x_67, 1);
+lean_inc(x_68);
+lean_dec(x_67);
+x_69 = l_Lean_findOLean(x_13, x_68);
+if (lean_obj_tag(x_69) == 0)
 {
-lean_object* x_74; lean_object* x_75; lean_object* x_76; 
-x_74 = lean_ctor_get(x_73, 0);
-lean_inc(x_74);
-x_75 = lean_ctor_get(x_73, 1);
-lean_inc(x_75);
+lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; 
+x_70 = lean_ctor_get(x_69, 0);
+lean_inc(x_70);
+x_71 = lean_ctor_get(x_69, 1);
+lean_inc(x_71);
+lean_dec(x_69);
+x_72 = l_System_FilePath_pathExists(x_70, x_71);
+x_73 = lean_ctor_get(x_72, 0);
+lean_inc(x_73);
+x_74 = lean_unbox(x_73);
 lean_dec(x_73);
-x_76 = lean_io_file_exists(x_74, x_75);
-if (lean_obj_tag(x_76) == 0)
+if (x_74 == 0)
 {
-lean_object* x_77; uint8_t x_78; 
-x_77 = lean_ctor_get(x_76, 0);
-lean_inc(x_77);
-x_78 = lean_unbox(x_77);
-lean_dec(x_77);
-if (x_78 == 0)
-{
-lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t 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_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
 lean_dec(x_7);
-x_79 = lean_ctor_get(x_76, 1);
-lean_inc(x_79);
-if (lean_is_exclusive(x_76)) {
- lean_ctor_release(x_76, 0);
- lean_ctor_release(x_76, 1);
- x_80 = x_76;
+x_75 = lean_ctor_get(x_72, 1);
+lean_inc(x_75);
+if (lean_is_exclusive(x_72)) {
+ lean_ctor_release(x_72, 0);
+ lean_ctor_release(x_72, 1);
+ x_76 = x_72;
 } else {
- lean_dec_ref(x_76);
- x_80 = lean_box(0);
+ lean_dec_ref(x_72);
+ x_76 = lean_box(0);
 }
-x_81 = l_Lean_importModules_importMods___closed__1;
-x_82 = lean_string_append(x_81, x_74);
-lean_dec(x_74);
-x_83 = l_Lean_importModules_importMods___closed__2;
-x_84 = lean_string_append(x_82, x_83);
-x_85 = 1;
-x_86 = l_Lean_Name_toString(x_13, x_85);
-x_87 = lean_string_append(x_84, x_86);
-lean_dec(x_86);
-x_88 = l_Lean_importModules_importMods___closed__3;
-x_89 = lean_string_append(x_87, x_88);
-x_90 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_90, 0, x_89);
-if (lean_is_scalar(x_80)) {
- x_91 = lean_alloc_ctor(1, 2, 0);
+x_77 = l_Lean_importModules_importMods___closed__1;
+x_78 = lean_string_append(x_77, x_70);
+lean_dec(x_70);
+x_79 = l_Lean_importModules_importMods___closed__2;
+x_80 = lean_string_append(x_78, x_79);
+x_81 = 1;
+x_82 = l_Lean_Name_toString(x_13, x_81);
+x_83 = lean_string_append(x_80, x_82);
+lean_dec(x_82);
+x_84 = l_Lean_importModules_importMods___closed__3;
+x_85 = lean_string_append(x_83, x_84);
+x_86 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_86, 0, x_85);
+if (lean_is_scalar(x_76)) {
+ x_87 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_91 = x_80;
- lean_ctor_set_tag(x_91, 1);
+ x_87 = x_76;
+ lean_ctor_set_tag(x_87, 1);
 }
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_79);
-return x_91;
+lean_ctor_set(x_87, 0, x_86);
+lean_ctor_set(x_87, 1, x_75);
+return x_87;
 }
 else
 {
-lean_object* x_92; lean_object* x_93; 
-x_92 = lean_ctor_get(x_76, 1);
-lean_inc(x_92);
-lean_dec(x_76);
-x_93 = l_Lean_importModules_importMods___lambda__1(x_74, x_13, x_7, x_68, x_2, x_92);
-lean_dec(x_74);
+lean_object* x_88; lean_object* x_89; 
+x_88 = lean_ctor_get(x_72, 1);
+lean_inc(x_88);
+lean_dec(x_72);
+x_89 = l_Lean_importModules_importMods___lambda__1(x_70, x_13, x_7, x_64, x_2, x_88);
+lean_dec(x_70);
+return x_89;
+}
+}
+else
+{
+lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; 
+lean_dec(x_13);
+lean_dec(x_7);
+x_90 = lean_ctor_get(x_69, 0);
+lean_inc(x_90);
+x_91 = lean_ctor_get(x_69, 1);
+lean_inc(x_91);
+if (lean_is_exclusive(x_69)) {
+ lean_ctor_release(x_69, 0);
+ lean_ctor_release(x_69, 1);
+ x_92 = x_69;
+} else {
+ lean_dec_ref(x_69);
+ x_92 = lean_box(0);
+}
+if (lean_is_scalar(x_92)) {
+ x_93 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_93 = x_92;
+}
+lean_ctor_set(x_93, 0, x_90);
+lean_ctor_set(x_93, 1, x_91);
 return x_93;
 }
 }
-else
-{
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; 
-lean_dec(x_74);
-lean_dec(x_13);
-lean_dec(x_7);
-x_94 = lean_ctor_get(x_76, 0);
-lean_inc(x_94);
-x_95 = lean_ctor_get(x_76, 1);
-lean_inc(x_95);
-if (lean_is_exclusive(x_76)) {
- lean_ctor_release(x_76, 0);
- lean_ctor_release(x_76, 1);
- x_96 = x_76;
-} else {
- lean_dec_ref(x_76);
- x_96 = lean_box(0);
-}
-if (lean_is_scalar(x_96)) {
- x_97 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_97 = x_96;
-}
-lean_ctor_set(x_97, 0, x_94);
-lean_ctor_set(x_97, 1, x_95);
-return x_97;
-}
-}
-else
-{
-lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-lean_dec(x_13);
-lean_dec(x_7);
-x_98 = lean_ctor_get(x_73, 0);
-lean_inc(x_98);
-x_99 = lean_ctor_get(x_73, 1);
-lean_inc(x_99);
-if (lean_is_exclusive(x_73)) {
- lean_ctor_release(x_73, 0);
- lean_ctor_release(x_73, 1);
- x_100 = x_73;
-} else {
- lean_dec_ref(x_73);
- x_100 = lean_box(0);
-}
-if (lean_is_scalar(x_100)) {
- x_101 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_101 = x_100;
-}
-lean_ctor_set(x_101, 0, x_98);
-lean_ctor_set(x_101, 1, x_99);
-return x_101;
-}
-}
 }
 else
 {
@@ -9753,28 +9683,18 @@ goto _start;
 }
 else
 {
-lean_object* x_103; 
+lean_object* x_95; 
 lean_dec(x_6);
-x_103 = lean_ctor_get(x_8, 1);
-lean_inc(x_103);
+x_95 = lean_ctor_get(x_8, 1);
+lean_inc(x_95);
 lean_dec(x_8);
 x_1 = x_7;
-x_3 = x_103;
+x_3 = x_95;
 goto _start;
 }
 }
 }
 }
-lean_object* l_IO_fileExists___at_Lean_importModules_importMods___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_IO_fileExists___at_Lean_importModules_importMods___spec__1(x_1, x_2, x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_4;
-}
-}
 lean_object* l_Lean_importModules_importMods___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
@@ -11222,7 +11142,7 @@ x_7 = l_Lean_withImportModules___rarg(x_1, x_2, x_6, x_4, x_5);
 return x_7;
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -11245,7 +11165,7 @@ return x_4;
 }
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__3(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__3(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -11283,7 +11203,7 @@ size_t x_15; size_t x_16; lean_object* x_17;
 x_15 = 0;
 x_16 = lean_usize_of_nat(x_7);
 lean_dec(x_7);
-x_17 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2(x_6, x_15, x_16, x_4);
+x_17 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2(x_6, x_15, x_16, x_4);
 lean_dec(x_6);
 x_2 = x_11;
 x_4 = x_17;
@@ -11297,7 +11217,7 @@ return x_4;
 }
 }
 }
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; uint8_t x_5; 
@@ -11324,13 +11244,13 @@ size_t x_7; size_t x_8; lean_object* x_9;
 x_7 = 0;
 x_8 = lean_usize_of_nat(x_3);
 lean_dec(x_3);
-x_9 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__3(x_2, x_7, x_8, x_1);
+x_9 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__3(x_2, x_7, x_8, x_1);
 return x_9;
 }
 }
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__1() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -11338,27 +11258,27 @@ x_1 = lean_mk_string("namespaces");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__2() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__1;
+x_2 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__3() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_NameSet_empty;
-x_2 = lean_alloc_closure((void*)(l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__1___boxed), 2, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__1___boxed), 2, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -11367,14 +11287,14 @@ lean_closure_set(x_1, 0, lean_box(0));
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__5() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__2;
+x_1 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__2;
 x_2 = l_Lean_mkTagDeclarationExtension___closed__1;
-x_3 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__3;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_3 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__3;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
@@ -11383,16 +11303,16 @@ lean_ctor_set(x_5, 3, x_4);
 return x_5;
 }
 }
-lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630_(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__5;
+x_2 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__5;
 x_3 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_mkTagDeclarationExtension___spec__3(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 size_t x_5; size_t x_6; lean_object* x_7; 
@@ -11400,12 +11320,12 @@ x_5 = lean_unbox_usize(x_2);
 lean_dec(x_2);
 x_6 = lean_unbox_usize(x_3);
 lean_dec(x_3);
-x_7 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__2(x_1, x_5, x_6, x_4);
+x_7 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__2(x_1, x_5, x_6, x_4);
 lean_dec(x_1);
 return x_7;
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 size_t x_5; size_t x_6; lean_object* x_7; 
@@ -11413,16 +11333,16 @@ x_5 = lean_unbox_usize(x_2);
 lean_dec(x_2);
 x_6 = lean_unbox_usize(x_3);
 lean_dec(x_3);
-x_7 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__3(x_1, x_5, x_6, x_4);
+x_7 = l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__3(x_1, x_5, x_6, x_4);
 lean_dec(x_1);
 return x_7;
 }
 }
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3630____spec__1(x_1, x_2);
+x_3 = l_Lean_mkStateFromImportedEntries___at_Lean_initFn____x40_Lean_Environment___hyg_3629____spec__1(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -13502,16 +13422,16 @@ l_Lean_importModules___closed__2 = _init_l_Lean_importModules___closed__2();
 lean_mark_persistent(l_Lean_importModules___closed__2);
 l_Lean_importModules___closed__3 = _init_l_Lean_importModules___closed__3();
 lean_mark_persistent(l_Lean_importModules___closed__3);
-l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__1 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__1();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__1);
-l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__2 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__2();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__2);
-l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__3 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__3();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__3);
-l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4);
-l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__5 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__5();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__5);
+l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__1 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__1();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__1);
+l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__2 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__2();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__2);
+l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__3 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__3();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__3);
+l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4);
+l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__5 = _init_l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__5();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__5);
 l_Lean_namespacesExt___closed__1 = _init_l_Lean_namespacesExt___closed__1();
 lean_mark_persistent(l_Lean_namespacesExt___closed__1);
 l_Lean_namespacesExt___closed__2 = _init_l_Lean_namespacesExt___closed__2();
@@ -13522,7 +13442,7 @@ l_Lean_namespacesExt___closed__4 = _init_l_Lean_namespacesExt___closed__4();
 lean_mark_persistent(l_Lean_namespacesExt___closed__4);
 l_Lean_namespacesExt___closed__5 = _init_l_Lean_namespacesExt___closed__5();
 lean_mark_persistent(l_Lean_namespacesExt___closed__5);
-res = l_Lean_initFn____x40_Lean_Environment___hyg_3630_(lean_io_mk_world());
+res = l_Lean_initFn____x40_Lean_Environment___hyg_3629_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_namespacesExt = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_namespacesExt);
diff --git a/stage0/stdlib/Lean/Expr.c b/stage0/stdlib/Lean/Expr.c
index 399a877fb0..49d6a7f5e8 100644
--- a/stage0/stdlib/Lean/Expr.c
+++ b/stage0/stdlib/Lean/Expr.c
@@ -353,6 +353,7 @@ lean_object* l_Lean_Expr_getArg_x21___boxed(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_Expr_bindingDomain_x21___closed__1;
 lean_object* l_Lean_Expr_isConst_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_BinderInfo_isInstImplicit_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 lean_object* l_Lean_Expr_instantiateLevelParamsCore_visit___at_Lean_Expr_instantiateLevelParams___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_ctorName___closed__3;
 lean_object* l_Lean_Expr_hasAnyFVar_visit___at_Lean_Expr_containsFVar___spec__1___boxed(lean_object*, lean_object*);
@@ -437,7 +438,6 @@ lean_object* l_Lean_Expr_ctorName(lean_object*);
 lean_object* l_Lean_Expr_replaceFVarId(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkApp9(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_isSort_match__1(lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
 lean_object* l_Lean_Expr_data___boxed(lean_object*);
 lean_object* l_Lean_Expr_setPPExplicit___closed__1;
 lean_object* lean_expr_update_proj(lean_object*, lean_object*);
@@ -5109,7 +5109,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_3 = l_Lean_mkConst(x_2, x_1);
 return x_3;
 }
diff --git a/stage0/stdlib/Lean/KeyedDeclsAttribute.c b/stage0/stdlib/Lean/KeyedDeclsAttribute.c
index 9c574fe892..0ef302f170 100644
--- a/stage0/stdlib/Lean/KeyedDeclsAttribute.c
+++ b/stage0/stdlib/Lean/KeyedDeclsAttribute.c
@@ -148,6 +148,7 @@ lean_object* l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__10;
 lean_object* l_Std_PersistentHashMap_findAux___at_Lean_KeyedDeclsAttribute_getValues___spec__4___rarg(lean_object*, size_t, lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_KeyedDeclsAttribute_Table_insert___spec__8(lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_KeyedDeclsAttribute_getValues___spec__9(lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 lean_object* l_Lean_KeyedDeclsAttribute_instInhabitedExtensionState___closed__2;
 lean_object* l_Std_AssocList_find_x3f___at_Lean_KeyedDeclsAttribute_getValues___spec__9___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_expand___at_Lean_KeyedDeclsAttribute_Table_insert___spec__16(lean_object*);
@@ -180,7 +181,6 @@ lean_object* l_Lean_ScopedEnvExtension_add___at_Lean_KeyedDeclsAttribute_init___
 lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___closed__2;
 extern lean_object* l_Lean_registerTagAttribute___lambda__6___closed__2;
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
 lean_object* l_Std_PersistentHashMap_findAtAux___at_Lean_KeyedDeclsAttribute_Table_insert___spec__4(lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAtCollisionNodeAux___at_Lean_KeyedDeclsAttribute_Table_insert___spec__13(lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___lambda__7___closed__2;
@@ -240,6 +240,7 @@ lean_object* lean_nat_mul(lean_object*, lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___lambda__3___boxed(lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_instInhabitedDef___closed__2;
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___lambda__7___closed__3;
 lean_object* l_Std_PersistentHashMap_insertAux_traverse___at_Lean_KeyedDeclsAttribute_Table_insert___spec__12___rarg(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_KeyedDeclsAttribute_init___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -275,7 +276,6 @@ lean_object* l_Std_AssocList_find_x3f___at_Lean_KeyedDeclsAttribute_getValues___
 lean_object* l_Std_PersistentHashMap_findAux___at_Lean_KeyedDeclsAttribute_getValues___spec__4(lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___lambda__7___closed__5;
 lean_object* l_Std_PersistentHashMap_insertAux___at_Lean_KeyedDeclsAttribute_Table_insert___spec__22(lean_object*);
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
 lean_object* l_Std_AssocList_find_x3f___at_Lean_KeyedDeclsAttribute_Table_insert___spec__6___rarg(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAux___at_Lean_KeyedDeclsAttribute_Table_insert___spec__11___rarg(lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_moveEntries___at_Lean_KeyedDeclsAttribute_Table_insert___spec__28(lean_object*);
@@ -3313,7 +3313,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__5;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__5;
 x_3 = l_Lean_mkConst(x_2, x_1);
 return x_3;
 }
@@ -3323,7 +3323,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_2 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_3 = l_Lean_mkConst(x_2, x_1);
 return x_3;
 }
diff --git a/stage0/stdlib/Lean/Meta/AppBuilder.c b/stage0/stdlib/Lean/Meta/AppBuilder.c
index 82fd5f60e5..7dcd31ac48 100644
--- a/stage0/stdlib/Lean/Meta/AppBuilder.c
+++ b/stage0/stdlib/Lean/Meta/AppBuilder.c
@@ -15,7 +15,6 @@ extern "C" {
 #endif
 lean_object* l___private_Lean_Meta_AppBuilder_0__Lean_Meta_mkAppMArgs_loop___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* l_Lean_throwError___at___private_Lean_Meta_AppBuilder_0__Lean_Meta_throwAppBuilderException___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* l___private_Lean_Meta_AppBuilder_0__Lean_Meta_throwAppBuilderException___rarg___closed__3;
 lean_object* l_Lean_Meta_mkImpCongrCtx(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkEqOfHEq___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -63,6 +62,7 @@ lean_object* l_Lean_Meta_mkDecideProof___closed__2;
 lean_object* l_Lean_Meta_mkPure___closed__2;
 lean_object* l_Lean_Meta_mkHEqSymm___closed__4;
 lean_object* l_Lean_Meta_mkCongr___closed__2;
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l___private_Lean_Meta_AppBuilder_0__Lean_Meta_mkAppMArgs_loop___closed__2;
 lean_object* l_Lean_Meta_mkProjection_match__2(lean_object*);
 lean_object* l_Lean_Meta_mkPure___closed__4;
@@ -6102,7 +6102,7 @@ static lean_object* _init_l_Lean_Meta_mkAppM___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Meta_mkAppM___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
diff --git a/stage0/stdlib/Lean/Meta/Basic.c b/stage0/stdlib/Lean/Meta/Basic.c
index 3f1c697d78..4e4cb98db8 100644
--- a/stage0/stdlib/Lean/Meta/Basic.c
+++ b/stage0/stdlib/Lean/Meta/Basic.c
@@ -19,9 +19,7 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withExistingLocalDeclsImp_
 lean_object* l_Lean_Meta_instBEqInfoCacheKey;
 lean_object* l_Lean_Meta_getLocalDecl_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instMonadMCtxMetaM___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* l_Lean_Meta_mkLetFVars___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_update_forall(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_resettingSynthInstanceCacheWhen___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instMonadMCtxMetaM___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -43,7 +41,6 @@ lean_object* l_Lean_Meta_withLocalDecl___at_Lean_Meta_withLocalDecls_loop___spec
 lean_object* l_Lean_Meta_isExprDefEqAux___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instInhabitedParamInfo___closed__1;
 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_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
 size_t l_Lean_Meta_TransparencyMode_hash(uint8_t);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 size_t l_Lean_Meta_InfoCacheKey_instHashableInfoCacheKey(lean_object*);
@@ -53,6 +50,7 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstanceImp_ma
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_fullApproxDefEqImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_synthPending___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_map1MetaM___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instantiateLambda(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp_match__2(lean_object*);
 lean_object* l_Lean_mkSort(lean_object*);
@@ -63,22 +61,19 @@ lean_object* l_Lean_Meta_getLocalInstances___boxed(lean_object*, lean_object*, l
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux_match__1(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_whnf___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDecls_loop_match__1(lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____closed__1;
 extern lean_object* l_Lean_withIncRecDepth___rarg___lambda__2___closed__2;
 uint8_t l_Lean_Meta_Config_zetaNonDep___default;
 lean_object* l_Lean_LocalDecl_userName(lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyOrSyntheticOpaqueExprMVar_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_whnfForall(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_getConstTemp_x3f_match__1(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__1;
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_synthPending___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_throwUnknownFVar___spec__1(lean_object*);
 lean_object* l_Lean_Meta_mapMetaM___rarg___lambda__1(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* l_Lean_MetavarContext_instantiateLevelMVars___at_Lean_Meta_instantiateLevelMVars___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 uint8_t l_USize_decEq(size_t, size_t);
 extern lean_object* l_Lean_InternalExceptionId_toString___closed__1;
 lean_object* lean_array_uget(lean_object*, size_t);
@@ -112,10 +107,9 @@ lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___
 lean_object* l_Lean_Core_restore(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instOrElseMetaM___closed__1;
 lean_object* l_Lean_Meta_occursCheck(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_MetavarContext_getExprAssignment_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_resetZetaFVarIds___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__2;
 lean_object* l_Lean_Meta_saveState___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withLocalDeclImp___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_getParamNames___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -134,6 +128,7 @@ lean_object* l_Lean_getConstInfo___at_Lean_Meta_mkConstWithFreshMVarLevels___spe
 lean_object* l_Lean_Meta_saveState(lean_object*);
 lean_object* l_Lean_Meta_State_mctx___default;
 lean_object* l_Lean_Meta_savingCache___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_withoutProofIrrelevance___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_lambdaTelescopeImp_process___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_lambdaTelescope(lean_object*);
 lean_object* l_Lean_Meta_elimMVarDeps(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -155,7 +150,6 @@ extern lean_object* l_Std_PersistentArray_empty___closed__1;
 extern lean_object* l_Std_PersistentHashMap_root___default___closed__2;
 lean_object* l_Lean_Meta_mkFreshExprMVarWithId___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_fullApproxDefEq(lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Meta_Basic_0__Lean_Meta_getConstTemp_x3f___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDecls_loop_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Meta_Basic_0__Lean_Meta_withNewBinderInfosImp___spec__1(lean_object*, size_t, size_t, lean_object*);
@@ -176,7 +170,9 @@ lean_object* l_Lean_Meta_orelse(lean_object*);
 lean_object* l_Lean_Meta_withTransparency___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_instantiate1(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_State_zetaFVarIds___default;
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1(lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
+lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____spec__1(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Meta_withNewLocalInstance___at___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp___spec__1(lean_object*);
 lean_object* l_Lean_Meta_withLocalDeclsD___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -208,31 +204,33 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewBinderInfosImp(lean
 lean_object* l_Lean_Meta_isReadOnlyLevelMVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAuxAux_process___rarg___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* l___private_Lean_Meta_Basic_0__Lean_Meta_isClassExpensive_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyLevelMVar___closed__2;
 lean_object* l_Lean_Meta_setInlineAttribute___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_instInhabitedPersistentArray___closed__1;
 lean_object* l_Lean_Meta_lambdaMetaTelescope_process_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withConfig___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_whnfI(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Meta_Basic_0__Lean_Meta_getConstTemp_x3f___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withReducibleAndInstances___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_resettingSynthInstanceCacheImpl___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withNewBinderInfos___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withMVarContext(lean_object*);
 lean_object* l_Lean_Meta_lambdaMetaTelescope_process_match__2(lean_object*);
 lean_object* l_Lean_Meta_modifyInferTypeCache(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getPostponed___boxed(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669_(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612_(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791_(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726_(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046_(lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_3_(lean_object*);
 lean_object* l_Lean_Meta_getPostponed___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDeclD(lean_object*);
 lean_object* l_Lean_Meta_withLocalDecls_loop___rarg___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instInhabitedCache___closed__1;
 lean_object* l_Lean_Meta_mapMetaM(lean_object*);
@@ -248,6 +246,7 @@ extern lean_object* l_Lean_instInhabitedException___closed__1;
 lean_object* l_Array_isEqvAux___at___private_Lean_Meta_Basic_0__Lean_Meta_withLocalContextImp___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateForallAux___closed__1;
 lean_object* l_Lean_Meta_forallTelescopeReducing(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____closed__1;
 lean_object* l_Lean_Meta_mkFreshTypeMVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyLevelMVar_match__1(lean_object*);
 lean_object* l_Lean_Meta_whnf___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -262,8 +261,8 @@ lean_object* l_Lean_mkAppN(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDeclsD(lean_object*);
 lean_object* l_Lean_Meta_inferType___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__1;
 lean_object* l_Lean_Meta_instantiateForall(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__2;
 lean_object* l_Lean_addMessageContextFull___at_Lean_Meta_instAddMessageContextMetaM___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalContext_setBinderInfo(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Meta_mkFreshExprMVarWithId_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -282,7 +281,9 @@ lean_object* l_Lean_Meta_instInhabitedMetaM(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_Meta_withNewLocalInstance___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instInhabitedCache;
 extern lean_object* l_Lean_Compiler_inlineAttrs;
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3;
 lean_object* l_Lean_Meta_restoreSynthInstanceCache(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateForallAux___closed__2;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarImpl_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux_process___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*);
@@ -294,10 +295,10 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewBinderInfosImp___ra
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getZetaFVarIds(lean_object*);
 lean_object* l___private_Lean_CoreM_0__Lean_Core_mkFreshNameImp(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__1;
 lean_object* l_Lean_Meta_map2MetaM___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_throwUnknownFVar(lean_object*);
 lean_object* l_Lean_mkFreshId___at_Lean_Meta_mkFreshExprMVarAt___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_instantiate_rev_range(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withNewBinderInfos___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldlM___at___private_Lean_Meta_Basic_0__Lean_Meta_withExistingLocalDeclsImp___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -313,7 +314,6 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducin
 lean_object* l_Lean_Meta_withTrackingZeta___rarg___lambda__1(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_object* l___private_Lean_Meta_Basic_0__Lean_Meta_getConstTemp_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__2(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_lambdaTelescopeImp_process(lean_object*);
 lean_object* l_Lean_Meta_instMonadBacktrackSavedStateMetaM;
 lean_object* l_Lean_Meta_getZetaFVarIds___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -322,10 +322,11 @@ lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_isClassQuick_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MetavarContext_getLevelAssignment_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDecls_loop___rarg___lambda__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__2;
 lean_object* l_Lean_Meta_resetZetaFVarIds___boxed(lean_object*);
 lean_object* l_Lean_Meta_mkConstWithFreshMVarLevels___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____boxed(lean_object*, lean_object*);
 uint8_t l___private_Lean_Meta_Basic_0__Lean_Meta_fvarsSizeLtMaxFVars(lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instMetaEvalMetaM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Meta_instMonadMCtxMetaM___closed__4;
 lean_object* l_Lean_Meta_instantiateForall___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -337,18 +338,22 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withMCtxImp(lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyOrSyntheticOpaqueExprMVar_match__1___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withNewMCtxDepth___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewFVar___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_InfoCacheKey_instHashableInfoCacheKey_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_3____closed__2;
 lean_object* lean_level_update_max(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getPostponed___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instMetaEvalMetaM___rarg___closed__2;
 lean_object* l_Lean_Meta_isDefEqStuckExceptionId;
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__1;
 lean_object* l_Lean_Meta_mkArrow___closed__2;
 uint8_t l_Lean_Expr_hasExprMVar(lean_object*);
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_getDefInfoTemp___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_renameMVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, 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*);
 lean_object* l_Lean_Meta_withNewBinderInfos(lean_object*);
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
@@ -356,6 +361,7 @@ lean_object* l_Lean_Meta_instMonadLCtxMetaM___lambda__1___boxed(lean_object*, le
 lean_object* l_Lean_Meta_withTransparency(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mapMetaM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_throwIsDefEqStuck___rarg(lean_object*);
 extern lean_object* l_Lean_MetavarContext_instInhabitedMetavarContext___closed__1;
 lean_object* l_Lean_Meta_instMonadBacktrackSavedStateMetaM___closed__2;
@@ -381,6 +387,7 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewBinderInfosImp_matc
 lean_object* l_Lean_Meta_whnf___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getMVarDecl___closed__2;
 lean_object* l_Lean_Meta_renameMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 lean_object* l_Nat_foldM_loop___at_Lean_Meta_mkFreshLevelMVars___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isExprMVarAssigned___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
@@ -388,13 +395,13 @@ uint8_t l_Lean_Meta_ParamInfo_hasFwdDeps___default;
 lean_object* l_Lean_Meta_withNewLocalInstance___at___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_MetaM_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyLevelMVar_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withReducibleAndInstances___rarg___lambda__1(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_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instantiateLocalDeclMVars_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_LocalDecl_binderInfo(lean_object*);
 lean_object* l_Lean_Meta_setInlineAttribute_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_savingCache___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_inferTypeRef;
 lean_object* l_Lean_Meta_getDelayedAssignment_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -410,7 +417,6 @@ lean_object* l_Lean_Meta_instantiateLambda___boxed(lean_object*, lean_object*, l
 lean_object* l_Lean_Meta_resettingSynthInstanceCacheWhen___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 size_t l_Lean_Expr_hash(lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyExprMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_lambdaTelescopeImp_process_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstanceImp(lean_object*);
 lean_object* l_Lean_getConstInfo___at_Lean_Meta_mkConstWithFreshMVarLevels___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -423,7 +429,6 @@ uint8_t l_Lean_Meta_Config_constApprox___default;
 lean_object* l_Lean_Meta_map2MetaM___rarg___lambda__2(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_forallTelescopeReducingAuxAux_process(lean_object*);
 lean_object* l_Lean_Meta_lambdaMetaTelescope(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Meta_Basic_0__Lean_Meta_withNewBinderInfosImp___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_isClassExpensive_x3f___closed__1;
 lean_object* l_Lean_Meta_MetaM_toIO___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -442,12 +447,10 @@ lean_object* l_Lean_Meta_Cache_whnfAll___default;
 lean_object* l_Lean_Meta_liftMkBindingM(lean_object*);
 lean_object* l_Lean_printTraces___at_Lean_Core_instMetaEvalCoreM___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withNewLocalInstances(lean_object*);
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1(lean_object*);
 lean_object* l_Lean_Meta_approxDefEq___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_orelseMergeErrorsImp(lean_object*);
 lean_object* l_Lean_Meta_instInhabitedSavedState___closed__2;
 lean_object* l_Lean_Meta_withAtLeastTransparency___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____closed__1;
 extern lean_object* l_Lean_instInhabitedExpr;
 uint8_t l_Lean_Meta_Config_ctxApprox___default;
 lean_object* l_Lean_Meta_map1MetaM(lean_object*, lean_object*);
@@ -468,12 +471,12 @@ lean_object* l_Lean_Meta_ParamInfo_backDeps___default;
 uint8_t l_Lean_Meta_Config_quasiPatternApprox___default;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstanceImp_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_liftMetaM(lean_object*, lean_object*);
-lean_object* l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImpAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mapErrorImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeImp(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateLambdaAux___closed__1;
 lean_object* l_Lean_Meta_getParamNames___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____closed__1;
 lean_object* l_Lean_Meta_resetZetaFVarIds___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withDefault___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_update_let(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -485,7 +488,7 @@ lean_object* l_Lean_Meta_liftMkBindingM___rarg___closed__1;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateLambdaAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallMetaTelescopeReducing___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_setEnv___at_Lean_Meta_setInlineAttribute___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(lean_object*, lean_object*);
+uint8_t l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(lean_object*, lean_object*);
 lean_object* l_Lean_mkFVar(lean_object*);
 lean_object* l_Lean_Meta_getParamNames___lambda__1___boxed__const__1;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -510,11 +513,11 @@ lean_object* l_Lean_Meta_withIncRecDepth___rarg(lean_object*, lean_object*, lean
 lean_object* l_Lean_Meta_getMVarDecl___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_findLocalDecl_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instMonadMCtxMetaM___closed__5;
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Meta_ParamInfo_isExplicit(lean_object*);
 lean_object* lean_expr_update_proj(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withLocalDeclImp(lean_object*);
 lean_object* l_Lean_Meta_instInhabitedParamInfo;
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____closed__1;
 lean_object* l_Lean_Meta_lambdaLetTelescope(lean_object*);
 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*);
 lean_object* l_Lean_registerInternalExceptionId(lean_object*, lean_object*);
@@ -560,7 +563,6 @@ lean_object* l_Std_HashMapImp_insert___at_Lean_MetavarContext_instantiateExprMVa
 lean_object* l_Lean_Meta_mkFreshLevelMVars___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_FunInfo_resultDeps___default;
 lean_object* l_Lean_throwError___at_Lean_Meta_mkConstWithFreshMVarLevels___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____closed__1;
 lean_object* l_Lean_MetavarContext_instantiateLevelMVars___at_Lean_Meta_instantiateMVars___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setMVarKind___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLetDecl___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -572,7 +574,6 @@ lean_object* l_Lean_Meta_getLocalDecl(lean_object*, lean_object*, lean_object*,
 uint8_t lean_expr_eqv(lean_object*, lean_object*);
 extern lean_object* l_Lean_resetTraceState___rarg___lambda__1___closed__1;
 lean_object* l_Lean_Meta_withLocalDecls_loop___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3;
 uint8_t l_Lean_Expr_isMVar(lean_object*);
 lean_object* lean_expr_update_sort(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_resettingSynthInstanceCache(lean_object*);
@@ -583,11 +584,11 @@ lean_object* l_Lean_Meta_instBEqInfoCacheKey___closed__1;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkFreshExprMVar(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_inferType___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__2(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_getDefInfoTemp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_hasMVar(lean_object*);
 lean_object* l_Lean_Meta_mapErrorImp(lean_object*);
 lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDecls(lean_object*);
 lean_object* l_Lean_Meta_instMonadMCtxMetaM;
 lean_object* l_Lean_Meta_throwUnknownFVar___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -603,9 +604,9 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateForallAux(lean_
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_lambdaTelescopeAux_match__1(lean_object*);
 lean_object* l_Lean_MetavarContext_assignLevel(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_elimMVarDeps___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Level_normalize(lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instMonadMCtxMetaM___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withMVarContext___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedExpr___closed__1;
@@ -625,7 +626,6 @@ lean_object* l_Lean_throwUnknownConstant___at___private_Lean_Meta_Basic_0__Lean_
 lean_object* l_Lean_LocalContext_addDecl(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateLambdaAux___closed__2;
 lean_object* l_Lean_Meta_isExprDefEqAuxRef;
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getLocalDeclFromUserName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp(lean_object*);
 lean_object* l_Lean_Meta_withLCtx(lean_object*);
@@ -655,7 +655,6 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_savingCacheImpl(lean_objec
 lean_object* l_Lean_Meta_throwIsDefEqStuck___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instMonadLCtxMetaM___closed__1;
 lean_object* l_Lean_Meta_instMonadLCtxMetaM___closed__2;
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__1;
 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_object* l_Lean_Meta_instMonadMCtxMetaM___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -676,7 +675,6 @@ lean_object* l_Lean_Meta_withMVarContext___rarg___lambda__1(lean_object*, lean_o
 lean_object* l_Lean_Meta_inferType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkFreshId___at_Lean_Meta_mkFreshExprMVarAt___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getLocalDecl_match__1(lean_object*);
-lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarImpl(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Meta_TransparencyMode_lt(uint8_t, uint8_t);
 lean_object* l_Lean_Meta_restoreSynthInstanceCache___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -686,10 +684,8 @@ lean_object* l_Lean_Meta_assignExprMVar___boxed(lean_object*, lean_object*, lean
 lean_object* l_Lean_Meta_isDelayedAssigned(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDecls___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_isEqvAux___at___private_Lean_Meta_Basic_0__Lean_Meta_withLocalContextImp___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_isReducible___at___private_Lean_Meta_Basic_0__Lean_Meta_getDefInfoTemp___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_isClassExpensive_x3f___lambda__1___boxed(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_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getMVarDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_saveAndResetSynthInstanceCache___boxed(lean_object*);
 lean_object* l_Lean_MetavarContext_MkBinding_mkBinding(uint8_t, lean_object*, lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*);
@@ -717,6 +713,7 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux
 lean_object* l_Lean_Expr_withAppAux___at_Lean_Meta_instantiateMVars___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_HashMap_instInhabitedHashMap___closed__1;
 lean_object* l_Lean_Meta_withNewLocalInstance___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____closed__1;
 lean_object* l_Lean_Meta_forallMetaTelescope(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_modifyPostponed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withConfig(lean_object*);
@@ -727,6 +724,7 @@ lean_object* l_Lean_Meta_modifyInferTypeCache_match__1(lean_object*);
 lean_object* l_Lean_Meta_withNewMCtxDepth(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarAtCore(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_MetavarContext_occursCheck(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_withoutProofIrrelevance(lean_object*);
 lean_object* l_Lean_Meta_MetaM_toIO_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_shouldReduceReducibleOnly(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkFreshTypeMVar(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -744,8 +742,7 @@ lean_object* l_Lean_Meta_withTrackingZeta___rarg(lean_object*, lean_object*, lea
 lean_object* l_Lean_Meta_mkFreshLevelMVar___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Core_instInhabitedState___closed__2;
 lean_object* l_Lean_Meta_instInhabitedInfoCacheKey___closed__1;
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__2;
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____closed__1;
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__2;
 lean_object* l_List_mapM___at_Lean_Meta_instantiateMVars___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setInlineAttribute_match__1(lean_object*);
 lean_object* l_Lean_Meta_setInlineAttribute(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -761,6 +758,7 @@ lean_object* l_Lean_Meta_Cache_funInfo___default___closed__2;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withLocalContextImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyOrSyntheticOpaqueExprMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarWithIdCore(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__1;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_orelseMergeErrorsImp_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux_process_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarCore(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -770,6 +768,7 @@ uint8_t l_Lean_Meta_ParamInfo_implicit___default;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarWithIdCore___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_Meta_saveAndResetSynthInstanceCache(lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_MetavarContext_instantiateExprMVars___spec__1(lean_object*, lean_object*);
+lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__2(lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_getParamNames___spec__1(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_local_ctx_find(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAuxAux_process___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -801,11 +800,13 @@ lean_object* l_Lean_Meta_getLocalDeclFromUserName___closed__2;
 lean_object* l_Lean_Meta_setPostponed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_saveState___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withReducible(lean_object*);
+lean_object* l_Lean_Meta_withoutProofIrrelevance___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_fvarsSizeLtMaxFVars_match__1(lean_object*);
 lean_object* l_Lean_Meta_forallBoundedTelescope___rarg___lambda__1(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*);
 lean_object* l_Lean_Meta_getConfig(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescope___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Meta_Config_proofIrrelevance___default;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewBinderInfosImp_match__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux_process_match__1(lean_object*);
 lean_object* l_Lean_Meta_lambdaLetTelescope___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -824,6 +825,7 @@ lean_object* l_Lean_Meta_forallTelescopeReducing___rarg___lambda__1(lean_object*
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_shouldReduceAll___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_update_const(lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_withLocalDeclsD___spec__1___rarg(size_t, size_t, lean_object*);
 uint8_t lean_is_class(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withNewLocalInstances___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -831,6 +833,7 @@ lean_object* l_Lean_Meta_instAddMessageContextMetaM;
 lean_object* l_Lean_Meta_mapError___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescopeReducing___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkFreshLevelMVar___boxed(lean_object*);
+uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_getDefInfoTemp_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_isClassImp_x3f_match__1(lean_object*);
 lean_object* l_Lean_Meta_forallBoundedTelescope___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -851,6 +854,7 @@ lean_object* l_Lean_Meta_SavedState_restore___boxed(lean_object*, lean_object*,
 lean_object* l_Lean_Meta_resetZetaFVarIds(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImpAux___rarg___lambda__1(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_withNewLocalInstancesImpAux___at_Lean_Meta_withNewLocalInstances___spec__1(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__2;
 lean_object* l_Lean_getReducibilityStatus___at___private_Lean_Meta_Basic_0__Lean_Meta_getDefInfoTemp___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withTransparency___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_modifyInferTypeCache___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -953,6 +957,14 @@ x_1 = 1;
 return x_1;
 }
 }
+static uint8_t _init_l_Lean_Meta_Config_proofIrrelevance___default() {
+_start:
+{
+uint8_t x_1; 
+x_1 = 1;
+return x_1;
+}
+}
 static uint8_t _init_l_Lean_Meta_ParamInfo_implicit___default() {
 _start:
 {
@@ -1085,7 +1097,7 @@ x_1 = l_Lean_Meta_instInhabitedInfoCacheKey___closed__1;
 return x_1;
 }
 }
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
@@ -1107,24 +1119,24 @@ x_13 = lean_apply_6(x_3, x_11, x_6, x_7, x_12, x_9, x_10);
 return x_13;
 }
 }
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1(lean_object* x_1) {
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1___rarg___boxed), 4, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1___rarg___boxed), 4, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236__match__1___rarg(x_1, x_2, x_3, x_4);
+x_5 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245__match__1___rarg(x_1, x_2, x_3, x_4);
 lean_dec(x_4);
 return x_5;
 }
 }
-uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(lean_object* x_1, lean_object* x_2) {
+uint8_t l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -1161,7 +1173,7 @@ return x_8;
 }
 }
 }
-uint8_t l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(lean_object* x_1, lean_object* x_2) {
+uint8_t l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
@@ -1191,28 +1203,28 @@ return x_12;
 else
 {
 uint8_t x_13; 
-x_13 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(x_5, x_8);
+x_13 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(x_5, x_8);
 return x_13;
 }
 }
 }
 }
-lean_object* l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____spec__1(x_1, x_2);
+x_3 = l___private_Init_Data_Option_Basic_0__beqOption____x40_Init_Data_Option_Basic___hyg_671____at___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(x_1, x_2);
+x_3 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 x_4 = lean_box(x_3);
@@ -1223,7 +1235,7 @@ static lean_object* _init_l_Lean_Meta_instBEqInfoCacheKey___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236____boxed), 2, 0);
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245____boxed), 2, 0);
 return x_1;
 }
 }
@@ -1528,7 +1540,7 @@ uint8_t x_1; uint8_t x_2; uint8_t x_3; lean_object* x_4;
 x_1 = 0;
 x_2 = 1;
 x_3 = 1;
-x_4 = lean_alloc_ctor(0, 0, 9);
+x_4 = lean_alloc_ctor(0, 0, 10);
 lean_ctor_set_uint8(x_4, 0, x_1);
 lean_ctor_set_uint8(x_4, 1, x_1);
 lean_ctor_set_uint8(x_4, 2, x_1);
@@ -1538,6 +1550,7 @@ lean_ctor_set_uint8(x_4, 5, x_2);
 lean_ctor_set_uint8(x_4, 6, x_3);
 lean_ctor_set_uint8(x_4, 7, x_1);
 lean_ctor_set_uint8(x_4, 8, x_3);
+lean_ctor_set_uint8(x_4, 9, x_3);
 return x_4;
 }
 }
@@ -3294,7 +3307,7 @@ lean_dec(x_2);
 return x_6;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -3302,17 +3315,17 @@ x_1 = lean_mk_string("Meta");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -3320,21 +3333,21 @@ x_1 = lean_mk_string("debug");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_3 = l_Lean_registerTraceClass(x_2, x_1);
 if (lean_obj_tag(x_3) == 0)
 {
@@ -3342,7 +3355,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_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_5 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_6 = l_Lean_registerTraceClass(x_5, x_4);
 return x_6;
 }
@@ -4432,7 +4445,7 @@ lean_dec(x_2);
 return x_7;
 }
 }
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; uint8_t x_9; 
@@ -4470,7 +4483,7 @@ return x_15;
 }
 }
 }
-lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -4495,7 +4508,7 @@ return x_7;
 }
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4503,46 +4516,46 @@ x_1 = lean_mk_string("whnf implementation was not set");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__2() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__1;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__1;
 x_2 = l_Lean_stringToMessageData(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; 
-x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__2;
-x_8 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_7, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__2;
+x_8 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_7, x_2, x_3, x_4, x_5, x_6);
 return x_8;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___boxed), 6, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___boxed), 6, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____closed__1;
-x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__2(x_2, x_1);
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____closed__1;
+x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__2(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -4550,11 +4563,11 @@ lean_dec(x_2);
 return x_7;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -4563,7 +4576,7 @@ lean_dec(x_1);
 return x_7;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4571,46 +4584,46 @@ x_1 = lean_mk_string("inferType implementation was not set");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__2() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__1;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__1;
 x_2 = l_Lean_stringToMessageData(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; 
-x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__2;
-x_8 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_7, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__2;
+x_8 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_7, x_2, x_3, x_4, x_5, x_6);
 return x_8;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___boxed), 6, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___boxed), 6, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____closed__1;
-x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__2(x_2, x_1);
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____closed__1;
+x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__2(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -4619,7 +4632,7 @@ lean_dec(x_1);
 return x_7;
 }
 }
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; uint8_t x_9; 
@@ -4657,7 +4670,7 @@ return x_15;
 }
 }
 }
-lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -4682,7 +4695,7 @@ return x_7;
 }
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4690,46 +4703,46 @@ x_1 = lean_mk_string("isDefEq implementation was not set");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__2() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__1;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__1;
 x_2 = l_Lean_stringToMessageData(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____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* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____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; lean_object* x_9; 
-x_8 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__2;
-x_9 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1(x_8, x_3, x_4, x_5, x_6, x_7);
+x_8 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__2;
+x_9 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1(x_8, x_3, x_4, x_5, x_6, x_7);
 return x_9;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___boxed), 7, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___boxed), 7, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____closed__1;
-x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__2(x_2, x_1);
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____closed__1;
+x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__2(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -4737,11 +4750,11 @@ lean_dec(x_2);
 return x_7;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____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* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____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_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+x_8 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____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);
@@ -4751,7 +4764,7 @@ lean_dec(x_1);
 return x_8;
 }
 }
-lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -4776,7 +4789,7 @@ return x_7;
 }
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; lean_object* x_8; lean_object* x_9; 
@@ -4788,28 +4801,28 @@ lean_ctor_set(x_9, 1, x_6);
 return x_9;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____lambda__1___boxed), 6, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____lambda__1___boxed), 6, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____closed__1;
-x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____spec__1(x_2, x_1);
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____closed__1;
+x_3 = l_IO_mkRef___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____spec__1(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____lambda__1(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____lambda__1(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -7620,7 +7633,7 @@ x_18 = l_Lean_KernelException_toMessageData___closed__3;
 x_19 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_19, 0, x_17);
 lean_ctor_set(x_19, 1, x_18);
-x_20 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1(x_19, x_2, x_3, x_4, x_5, x_12);
+x_20 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1(x_19, x_2, x_3, x_4, x_5, x_12);
 return x_20;
 }
 else
@@ -7681,7 +7694,7 @@ x_35 = l_Lean_KernelException_toMessageData___closed__3;
 x_36 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_36, 0, x_34);
 lean_ctor_set(x_36, 1, x_35);
-x_37 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____spec__1(x_36, x_2, x_3, x_4, x_5, x_29);
+x_37 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____spec__1(x_36, x_2, x_3, x_4, x_5, x_29);
 return x_37;
 }
 else
@@ -14242,7 +14255,7 @@ x_65 = lean_ctor_get(x_64, 1);
 lean_inc(x_65);
 lean_dec(x_64);
 x_66 = l_Lean_Meta_liftMkBindingM___rarg___closed__2;
-x_67 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_66, x_5, x_6, x_7, x_8, x_65);
+x_67 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_66, x_5, x_6, x_7, x_8, x_65);
 lean_dec(x_5);
 return x_67;
 }
@@ -14266,7 +14279,7 @@ x_73 = lean_ctor_get(x_72, 1);
 lean_inc(x_73);
 lean_dec(x_72);
 x_74 = l_Lean_Meta_liftMkBindingM___rarg___closed__2;
-x_75 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_74, x_5, x_6, x_7, x_8, x_73);
+x_75 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_74, x_5, x_6, x_7, x_8, x_73);
 lean_dec(x_5);
 return x_75;
 }
@@ -14472,7 +14485,7 @@ x_66 = lean_ctor_get(x_65, 1);
 lean_inc(x_66);
 lean_dec(x_65);
 x_67 = l_Lean_Meta_liftMkBindingM___rarg___closed__2;
-x_68 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_67, x_5, x_6, x_7, x_8, x_66);
+x_68 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_67, x_5, x_6, x_7, x_8, x_66);
 lean_dec(x_5);
 return x_68;
 }
@@ -14496,7 +14509,7 @@ x_74 = lean_ctor_get(x_73, 1);
 lean_inc(x_74);
 lean_dec(x_73);
 x_75 = l_Lean_Meta_liftMkBindingM___rarg___closed__2;
-x_76 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_75, x_5, x_6, x_7, x_8, x_74);
+x_76 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_75, x_5, x_6, x_7, x_8, x_74);
 lean_dec(x_5);
 return x_76;
 }
@@ -14778,7 +14791,7 @@ x_61 = lean_ctor_get(x_60, 1);
 lean_inc(x_61);
 lean_dec(x_60);
 x_62 = l_Lean_Meta_liftMkBindingM___rarg___closed__2;
-x_63 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_62, x_4, x_5, x_6, x_7, x_61);
+x_63 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_62, x_4, x_5, x_6, x_7, x_61);
 return x_63;
 }
 else
@@ -14801,7 +14814,7 @@ x_69 = lean_ctor_get(x_68, 1);
 lean_inc(x_69);
 lean_dec(x_68);
 x_70 = l_Lean_Meta_liftMkBindingM___rarg___closed__2;
-x_71 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_70, x_4, x_5, x_6, x_7, x_69);
+x_71 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_70, x_4, x_5, x_6, x_7, x_69);
 return x_71;
 }
 }
@@ -14917,7 +14930,7 @@ return x_12;
 }
 else
 {
-uint8_t x_13; uint8_t x_14; uint8_t x_15; uint8_t x_16; uint8_t x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; 
+uint8_t x_13; uint8_t x_14; uint8_t x_15; uint8_t x_16; uint8_t x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; 
 x_13 = lean_ctor_get_uint8(x_9, 0);
 x_14 = lean_ctor_get_uint8(x_9, 1);
 x_15 = lean_ctor_get_uint8(x_9, 2);
@@ -14926,71 +14939,75 @@ x_17 = lean_ctor_get_uint8(x_9, 4);
 x_18 = lean_ctor_get_uint8(x_9, 5);
 x_19 = lean_ctor_get_uint8(x_9, 6);
 x_20 = lean_ctor_get_uint8(x_9, 8);
+x_21 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_21 = 1;
-x_22 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_22, 0, x_13);
-lean_ctor_set_uint8(x_22, 1, x_14);
-lean_ctor_set_uint8(x_22, 2, x_15);
-lean_ctor_set_uint8(x_22, 3, x_16);
-lean_ctor_set_uint8(x_22, 4, x_17);
-lean_ctor_set_uint8(x_22, 5, x_18);
-lean_ctor_set_uint8(x_22, 6, x_19);
-lean_ctor_set_uint8(x_22, 7, x_21);
-lean_ctor_set_uint8(x_22, 8, x_20);
-lean_ctor_set(x_3, 0, x_22);
-x_23 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
-return x_23;
+x_22 = 1;
+x_23 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_23, 0, x_13);
+lean_ctor_set_uint8(x_23, 1, x_14);
+lean_ctor_set_uint8(x_23, 2, x_15);
+lean_ctor_set_uint8(x_23, 3, x_16);
+lean_ctor_set_uint8(x_23, 4, x_17);
+lean_ctor_set_uint8(x_23, 5, x_18);
+lean_ctor_set_uint8(x_23, 6, x_19);
+lean_ctor_set_uint8(x_23, 7, x_22);
+lean_ctor_set_uint8(x_23, 8, x_20);
+lean_ctor_set_uint8(x_23, 9, x_21);
+lean_ctor_set(x_3, 0, x_23);
+x_24 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+return x_24;
 }
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 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; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-x_24 = lean_ctor_get(x_3, 0);
-x_25 = lean_ctor_get(x_3, 1);
-x_26 = lean_ctor_get(x_3, 2);
-x_27 = lean_ctor_get(x_3, 3);
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* 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; lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_25 = lean_ctor_get(x_3, 0);
+x_26 = lean_ctor_get(x_3, 1);
+x_27 = lean_ctor_get(x_3, 2);
+x_28 = lean_ctor_get(x_3, 3);
+lean_inc(x_28);
 lean_inc(x_27);
 lean_inc(x_26);
 lean_inc(x_25);
-lean_inc(x_24);
 lean_dec(x_3);
-x_28 = lean_ctor_get_uint8(x_24, 0);
-x_29 = lean_ctor_get_uint8(x_24, 1);
-x_30 = lean_ctor_get_uint8(x_24, 2);
-x_31 = lean_ctor_get_uint8(x_24, 3);
-x_32 = lean_ctor_get_uint8(x_24, 4);
-x_33 = lean_ctor_get_uint8(x_24, 5);
-x_34 = lean_ctor_get_uint8(x_24, 6);
-x_35 = lean_ctor_get_uint8(x_24, 8);
-if (lean_is_exclusive(x_24)) {
- x_36 = x_24;
+x_29 = lean_ctor_get_uint8(x_25, 0);
+x_30 = lean_ctor_get_uint8(x_25, 1);
+x_31 = lean_ctor_get_uint8(x_25, 2);
+x_32 = lean_ctor_get_uint8(x_25, 3);
+x_33 = lean_ctor_get_uint8(x_25, 4);
+x_34 = lean_ctor_get_uint8(x_25, 5);
+x_35 = lean_ctor_get_uint8(x_25, 6);
+x_36 = lean_ctor_get_uint8(x_25, 8);
+x_37 = lean_ctor_get_uint8(x_25, 9);
+if (lean_is_exclusive(x_25)) {
+ x_38 = x_25;
 } else {
- lean_dec_ref(x_24);
- x_36 = lean_box(0);
+ lean_dec_ref(x_25);
+ x_38 = lean_box(0);
 }
-x_37 = 1;
-if (lean_is_scalar(x_36)) {
- x_38 = lean_alloc_ctor(0, 0, 9);
+x_39 = 1;
+if (lean_is_scalar(x_38)) {
+ x_40 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_38 = x_36;
+ x_40 = x_38;
 }
-lean_ctor_set_uint8(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, 1, x_29);
-lean_ctor_set_uint8(x_38, 2, x_30);
-lean_ctor_set_uint8(x_38, 3, x_31);
-lean_ctor_set_uint8(x_38, 4, x_32);
-lean_ctor_set_uint8(x_38, 5, x_33);
-lean_ctor_set_uint8(x_38, 6, x_34);
-lean_ctor_set_uint8(x_38, 7, x_37);
-lean_ctor_set_uint8(x_38, 8, x_35);
-x_39 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_25);
-lean_ctor_set(x_39, 2, x_26);
-lean_ctor_set(x_39, 3, x_27);
-x_40 = lean_apply_7(x_2, lean_box(0), x_1, x_39, x_4, x_5, x_6, x_7);
-return x_40;
+lean_ctor_set_uint8(x_40, 0, x_29);
+lean_ctor_set_uint8(x_40, 1, x_30);
+lean_ctor_set_uint8(x_40, 2, x_31);
+lean_ctor_set_uint8(x_40, 3, x_32);
+lean_ctor_set_uint8(x_40, 4, x_33);
+lean_ctor_set_uint8(x_40, 5, x_34);
+lean_ctor_set_uint8(x_40, 6, x_35);
+lean_ctor_set_uint8(x_40, 7, x_39);
+lean_ctor_set_uint8(x_40, 8, x_36);
+lean_ctor_set_uint8(x_40, 9, x_37);
+x_41 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_41, 0, x_40);
+lean_ctor_set(x_41, 1, x_26);
+lean_ctor_set(x_41, 2, x_27);
+lean_ctor_set(x_41, 3, x_28);
+x_42 = lean_apply_7(x_2, lean_box(0), x_1, x_41, x_4, x_5, x_6, x_7);
+return x_42;
 }
 }
 }
@@ -15022,6 +15039,135 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Meta_withTrackingZeta___rarg), 4, 0);
 return x_2;
 }
 }
+lean_object* l_Lean_Meta_withoutProofIrrelevance___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) {
+_start:
+{
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_3);
+if (x_8 == 0)
+{
+lean_object* x_9; uint8_t x_10; 
+x_9 = lean_ctor_get(x_3, 0);
+x_10 = !lean_is_exclusive(x_9);
+if (x_10 == 0)
+{
+uint8_t x_11; lean_object* x_12; 
+x_11 = 0;
+lean_ctor_set_uint8(x_9, 9, x_11);
+x_12 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+return x_12;
+}
+else
+{
+uint8_t x_13; uint8_t x_14; uint8_t x_15; uint8_t x_16; uint8_t x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; 
+x_13 = lean_ctor_get_uint8(x_9, 0);
+x_14 = lean_ctor_get_uint8(x_9, 1);
+x_15 = lean_ctor_get_uint8(x_9, 2);
+x_16 = lean_ctor_get_uint8(x_9, 3);
+x_17 = lean_ctor_get_uint8(x_9, 4);
+x_18 = lean_ctor_get_uint8(x_9, 5);
+x_19 = lean_ctor_get_uint8(x_9, 6);
+x_20 = lean_ctor_get_uint8(x_9, 7);
+x_21 = lean_ctor_get_uint8(x_9, 8);
+lean_dec(x_9);
+x_22 = 0;
+x_23 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_23, 0, x_13);
+lean_ctor_set_uint8(x_23, 1, x_14);
+lean_ctor_set_uint8(x_23, 2, x_15);
+lean_ctor_set_uint8(x_23, 3, x_16);
+lean_ctor_set_uint8(x_23, 4, x_17);
+lean_ctor_set_uint8(x_23, 5, x_18);
+lean_ctor_set_uint8(x_23, 6, x_19);
+lean_ctor_set_uint8(x_23, 7, x_20);
+lean_ctor_set_uint8(x_23, 8, x_21);
+lean_ctor_set_uint8(x_23, 9, x_22);
+lean_ctor_set(x_3, 0, x_23);
+x_24 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+return x_24;
+}
+}
+else
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* 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; lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_25 = lean_ctor_get(x_3, 0);
+x_26 = lean_ctor_get(x_3, 1);
+x_27 = lean_ctor_get(x_3, 2);
+x_28 = lean_ctor_get(x_3, 3);
+lean_inc(x_28);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_dec(x_3);
+x_29 = lean_ctor_get_uint8(x_25, 0);
+x_30 = lean_ctor_get_uint8(x_25, 1);
+x_31 = lean_ctor_get_uint8(x_25, 2);
+x_32 = lean_ctor_get_uint8(x_25, 3);
+x_33 = lean_ctor_get_uint8(x_25, 4);
+x_34 = lean_ctor_get_uint8(x_25, 5);
+x_35 = lean_ctor_get_uint8(x_25, 6);
+x_36 = lean_ctor_get_uint8(x_25, 7);
+x_37 = lean_ctor_get_uint8(x_25, 8);
+if (lean_is_exclusive(x_25)) {
+ x_38 = x_25;
+} else {
+ lean_dec_ref(x_25);
+ x_38 = lean_box(0);
+}
+x_39 = 0;
+if (lean_is_scalar(x_38)) {
+ x_40 = lean_alloc_ctor(0, 0, 10);
+} else {
+ x_40 = x_38;
+}
+lean_ctor_set_uint8(x_40, 0, x_29);
+lean_ctor_set_uint8(x_40, 1, x_30);
+lean_ctor_set_uint8(x_40, 2, x_31);
+lean_ctor_set_uint8(x_40, 3, x_32);
+lean_ctor_set_uint8(x_40, 4, x_33);
+lean_ctor_set_uint8(x_40, 5, x_34);
+lean_ctor_set_uint8(x_40, 6, x_35);
+lean_ctor_set_uint8(x_40, 7, x_36);
+lean_ctor_set_uint8(x_40, 8, x_37);
+lean_ctor_set_uint8(x_40, 9, x_39);
+x_41 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_41, 0, x_40);
+lean_ctor_set(x_41, 1, x_26);
+lean_ctor_set(x_41, 2, x_27);
+lean_ctor_set(x_41, 3, x_28);
+x_42 = lean_apply_7(x_2, lean_box(0), x_1, x_41, x_4, x_5, x_6, x_7);
+return x_42;
+}
+}
+}
+lean_object* l_Lean_Meta_withoutProofIrrelevance___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_dec(x_2);
+x_6 = lean_alloc_closure((void*)(l_Lean_Meta_withoutProofIrrelevance___rarg___lambda__1), 7, 1);
+lean_closure_set(x_6, 0, x_4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_apply_2(x_7, lean_box(0), x_6);
+x_9 = lean_ctor_get(x_1, 1);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_apply_1(x_9, lean_box(0));
+x_11 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_8, x_10);
+return x_11;
+}
+}
+lean_object* l_Lean_Meta_withoutProofIrrelevance(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Meta_withoutProofIrrelevance___rarg), 4, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Meta_withTransparency___rarg___lambda__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
@@ -15084,7 +15230,7 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
 x_21 = lean_ctor_get_uint8(x_10, 0);
 x_22 = lean_ctor_get_uint8(x_10, 1);
 x_23 = lean_ctor_get_uint8(x_10, 2);
@@ -15093,162 +15239,166 @@ x_25 = lean_ctor_get_uint8(x_10, 4);
 x_26 = lean_ctor_get_uint8(x_10, 6);
 x_27 = lean_ctor_get_uint8(x_10, 7);
 x_28 = lean_ctor_get_uint8(x_10, 8);
+x_29 = lean_ctor_get_uint8(x_10, 9);
 lean_dec(x_10);
-x_29 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_29, 0, x_21);
-lean_ctor_set_uint8(x_29, 1, x_22);
-lean_ctor_set_uint8(x_29, 2, x_23);
-lean_ctor_set_uint8(x_29, 3, x_24);
-lean_ctor_set_uint8(x_29, 4, x_25);
-lean_ctor_set_uint8(x_29, 5, x_1);
-lean_ctor_set_uint8(x_29, 6, x_26);
-lean_ctor_set_uint8(x_29, 7, x_27);
-lean_ctor_set_uint8(x_29, 8, x_28);
-lean_ctor_set(x_4, 0, x_29);
-x_30 = lean_apply_7(x_3, lean_box(0), x_2, x_4, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_30) == 0)
+x_30 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_30, 0, x_21);
+lean_ctor_set_uint8(x_30, 1, x_22);
+lean_ctor_set_uint8(x_30, 2, x_23);
+lean_ctor_set_uint8(x_30, 3, x_24);
+lean_ctor_set_uint8(x_30, 4, x_25);
+lean_ctor_set_uint8(x_30, 5, x_1);
+lean_ctor_set_uint8(x_30, 6, x_26);
+lean_ctor_set_uint8(x_30, 7, x_27);
+lean_ctor_set_uint8(x_30, 8, x_28);
+lean_ctor_set_uint8(x_30, 9, x_29);
+lean_ctor_set(x_4, 0, x_30);
+x_31 = lean_apply_7(x_3, lean_box(0), x_2, x_4, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_31) == 0)
 {
-lean_object* x_31; lean_object* x_32; lean_object* 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_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_32 = lean_ctor_get(x_31, 0);
 lean_inc(x_32);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_33 = x_30;
+x_33 = lean_ctor_get(x_31, 1);
+lean_inc(x_33);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_34 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_33 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_34 = lean_box(0);
 }
-if (lean_is_scalar(x_33)) {
- x_34 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_34)) {
+ x_35 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_34 = x_33;
+ x_35 = x_34;
 }
-lean_ctor_set(x_34, 0, x_31);
-lean_ctor_set(x_34, 1, x_32);
-return x_34;
+lean_ctor_set(x_35, 0, x_32);
+lean_ctor_set(x_35, 1, x_33);
+return x_35;
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_35 = lean_ctor_get(x_30, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_30, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_36 = lean_ctor_get(x_31, 0);
 lean_inc(x_36);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_37 = x_30;
+x_37 = lean_ctor_get(x_31, 1);
+lean_inc(x_37);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_38 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_37 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_38 = lean_box(0);
 }
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_38)) {
+ x_39 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_38 = x_37;
+ x_39 = x_38;
 }
-lean_ctor_set(x_38, 0, x_35);
-lean_ctor_set(x_38, 1, x_36);
-return x_38;
+lean_ctor_set(x_39, 0, x_36);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-x_39 = lean_ctor_get(x_4, 0);
-x_40 = lean_ctor_get(x_4, 1);
-x_41 = lean_ctor_get(x_4, 2);
-x_42 = lean_ctor_get(x_4, 3);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+x_40 = lean_ctor_get(x_4, 0);
+x_41 = lean_ctor_get(x_4, 1);
+x_42 = lean_ctor_get(x_4, 2);
+x_43 = lean_ctor_get(x_4, 3);
+lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
 lean_inc(x_40);
-lean_inc(x_39);
 lean_dec(x_4);
-x_43 = lean_ctor_get_uint8(x_39, 0);
-x_44 = lean_ctor_get_uint8(x_39, 1);
-x_45 = lean_ctor_get_uint8(x_39, 2);
-x_46 = lean_ctor_get_uint8(x_39, 3);
-x_47 = lean_ctor_get_uint8(x_39, 4);
-x_48 = lean_ctor_get_uint8(x_39, 6);
-x_49 = lean_ctor_get_uint8(x_39, 7);
-x_50 = lean_ctor_get_uint8(x_39, 8);
-if (lean_is_exclusive(x_39)) {
- x_51 = x_39;
+x_44 = lean_ctor_get_uint8(x_40, 0);
+x_45 = lean_ctor_get_uint8(x_40, 1);
+x_46 = lean_ctor_get_uint8(x_40, 2);
+x_47 = lean_ctor_get_uint8(x_40, 3);
+x_48 = lean_ctor_get_uint8(x_40, 4);
+x_49 = lean_ctor_get_uint8(x_40, 6);
+x_50 = lean_ctor_get_uint8(x_40, 7);
+x_51 = lean_ctor_get_uint8(x_40, 8);
+x_52 = lean_ctor_get_uint8(x_40, 9);
+if (lean_is_exclusive(x_40)) {
+ x_53 = x_40;
 } else {
- lean_dec_ref(x_39);
- x_51 = lean_box(0);
+ lean_dec_ref(x_40);
+ x_53 = lean_box(0);
 }
-if (lean_is_scalar(x_51)) {
- x_52 = lean_alloc_ctor(0, 0, 9);
+if (lean_is_scalar(x_53)) {
+ x_54 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_52 = x_51;
+ x_54 = x_53;
 }
-lean_ctor_set_uint8(x_52, 0, x_43);
-lean_ctor_set_uint8(x_52, 1, x_44);
-lean_ctor_set_uint8(x_52, 2, x_45);
-lean_ctor_set_uint8(x_52, 3, x_46);
-lean_ctor_set_uint8(x_52, 4, x_47);
-lean_ctor_set_uint8(x_52, 5, x_1);
-lean_ctor_set_uint8(x_52, 6, x_48);
-lean_ctor_set_uint8(x_52, 7, x_49);
-lean_ctor_set_uint8(x_52, 8, x_50);
-x_53 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_40);
-lean_ctor_set(x_53, 2, x_41);
-lean_ctor_set(x_53, 3, x_42);
-x_54 = lean_apply_7(x_3, lean_box(0), x_2, x_53, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_54) == 0)
+lean_ctor_set_uint8(x_54, 0, x_44);
+lean_ctor_set_uint8(x_54, 1, x_45);
+lean_ctor_set_uint8(x_54, 2, x_46);
+lean_ctor_set_uint8(x_54, 3, x_47);
+lean_ctor_set_uint8(x_54, 4, x_48);
+lean_ctor_set_uint8(x_54, 5, x_1);
+lean_ctor_set_uint8(x_54, 6, x_49);
+lean_ctor_set_uint8(x_54, 7, x_50);
+lean_ctor_set_uint8(x_54, 8, x_51);
+lean_ctor_set_uint8(x_54, 9, x_52);
+x_55 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_55, 0, x_54);
+lean_ctor_set(x_55, 1, x_41);
+lean_ctor_set(x_55, 2, x_42);
+lean_ctor_set(x_55, 3, x_43);
+x_56 = lean_apply_7(x_3, lean_box(0), x_2, x_55, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_56) == 0)
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-x_55 = lean_ctor_get(x_54, 0);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_54, 1);
-lean_inc(x_56);
-if (lean_is_exclusive(x_54)) {
- lean_ctor_release(x_54, 0);
- lean_ctor_release(x_54, 1);
- x_57 = x_54;
+lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_57 = lean_ctor_get(x_56, 0);
+lean_inc(x_57);
+x_58 = lean_ctor_get(x_56, 1);
+lean_inc(x_58);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ x_59 = x_56;
 } else {
- lean_dec_ref(x_54);
- x_57 = lean_box(0);
+ lean_dec_ref(x_56);
+ x_59 = lean_box(0);
 }
-if (lean_is_scalar(x_57)) {
- x_58 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_59)) {
+ x_60 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_58 = x_57;
+ x_60 = x_59;
 }
-lean_ctor_set(x_58, 0, x_55);
-lean_ctor_set(x_58, 1, x_56);
-return x_58;
+lean_ctor_set(x_60, 0, x_57);
+lean_ctor_set(x_60, 1, x_58);
+return x_60;
 }
 else
 {
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-x_59 = lean_ctor_get(x_54, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_54, 1);
-lean_inc(x_60);
-if (lean_is_exclusive(x_54)) {
- lean_ctor_release(x_54, 0);
- lean_ctor_release(x_54, 1);
- x_61 = x_54;
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_61 = lean_ctor_get(x_56, 0);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_56, 1);
+lean_inc(x_62);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ x_63 = x_56;
 } else {
- lean_dec_ref(x_54);
- x_61 = lean_box(0);
+ lean_dec_ref(x_56);
+ x_63 = lean_box(0);
 }
-if (lean_is_scalar(x_61)) {
- x_62 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_63)) {
+ x_64 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_62 = x_61;
+ x_64 = x_63;
 }
-lean_ctor_set(x_62, 0, x_59);
-lean_ctor_set(x_62, 1, x_60);
-return x_62;
+lean_ctor_set(x_64, 0, x_61);
+lean_ctor_set(x_64, 1, x_62);
+return x_64;
 }
 }
 }
@@ -15366,7 +15516,7 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; 
 x_21 = lean_ctor_get_uint8(x_9, 0);
 x_22 = lean_ctor_get_uint8(x_9, 1);
 x_23 = lean_ctor_get_uint8(x_9, 2);
@@ -15375,164 +15525,168 @@ x_25 = lean_ctor_get_uint8(x_9, 4);
 x_26 = lean_ctor_get_uint8(x_9, 6);
 x_27 = lean_ctor_get_uint8(x_9, 7);
 x_28 = lean_ctor_get_uint8(x_9, 8);
+x_29 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_29 = 1;
-x_30 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_30, 0, x_21);
-lean_ctor_set_uint8(x_30, 1, x_22);
-lean_ctor_set_uint8(x_30, 2, x_23);
-lean_ctor_set_uint8(x_30, 3, x_24);
-lean_ctor_set_uint8(x_30, 4, x_25);
-lean_ctor_set_uint8(x_30, 5, x_29);
-lean_ctor_set_uint8(x_30, 6, x_26);
-lean_ctor_set_uint8(x_30, 7, x_27);
-lean_ctor_set_uint8(x_30, 8, x_28);
-lean_ctor_set(x_3, 0, x_30);
-x_31 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_31) == 0)
+x_30 = 1;
+x_31 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_31, 0, x_21);
+lean_ctor_set_uint8(x_31, 1, x_22);
+lean_ctor_set_uint8(x_31, 2, x_23);
+lean_ctor_set_uint8(x_31, 3, x_24);
+lean_ctor_set_uint8(x_31, 4, x_25);
+lean_ctor_set_uint8(x_31, 5, x_30);
+lean_ctor_set_uint8(x_31, 6, x_26);
+lean_ctor_set_uint8(x_31, 7, x_27);
+lean_ctor_set_uint8(x_31, 8, x_28);
+lean_ctor_set_uint8(x_31, 9, x_29);
+lean_ctor_set(x_3, 0, x_31);
+x_32 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_31, 0);
-lean_inc(x_32);
-x_33 = lean_ctor_get(x_31, 1);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_33 = lean_ctor_get(x_32, 0);
 lean_inc(x_33);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_34 = x_31;
+x_34 = lean_ctor_get(x_32, 1);
+lean_inc(x_34);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_35 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_34 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_35 = lean_box(0);
 }
-if (lean_is_scalar(x_34)) {
- x_35 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_35)) {
+ x_36 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_35 = x_34;
+ x_36 = x_35;
 }
-lean_ctor_set(x_35, 0, x_32);
-lean_ctor_set(x_35, 1, x_33);
-return x_35;
+lean_ctor_set(x_36, 0, x_33);
+lean_ctor_set(x_36, 1, x_34);
+return x_36;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_36 = lean_ctor_get(x_31, 0);
-lean_inc(x_36);
-x_37 = lean_ctor_get(x_31, 1);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_37 = lean_ctor_get(x_32, 0);
 lean_inc(x_37);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_38 = x_31;
+x_38 = lean_ctor_get(x_32, 1);
+lean_inc(x_38);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_39 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_38 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_39 = lean_box(0);
 }
-if (lean_is_scalar(x_38)) {
- x_39 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_39)) {
+ x_40 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_39 = x_38;
+ x_40 = x_39;
 }
-lean_ctor_set(x_39, 0, x_36);
-lean_ctor_set(x_39, 1, x_37);
-return x_39;
+lean_ctor_set(x_40, 0, x_37);
+lean_ctor_set(x_40, 1, x_38);
+return x_40;
 }
 }
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_40 = lean_ctor_get(x_3, 0);
-x_41 = lean_ctor_get(x_3, 1);
-x_42 = lean_ctor_get(x_3, 2);
-x_43 = lean_ctor_get(x_3, 3);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_41 = lean_ctor_get(x_3, 0);
+x_42 = lean_ctor_get(x_3, 1);
+x_43 = lean_ctor_get(x_3, 2);
+x_44 = lean_ctor_get(x_3, 3);
+lean_inc(x_44);
 lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
-lean_inc(x_40);
 lean_dec(x_3);
-x_44 = lean_ctor_get_uint8(x_40, 0);
-x_45 = lean_ctor_get_uint8(x_40, 1);
-x_46 = lean_ctor_get_uint8(x_40, 2);
-x_47 = lean_ctor_get_uint8(x_40, 3);
-x_48 = lean_ctor_get_uint8(x_40, 4);
-x_49 = lean_ctor_get_uint8(x_40, 6);
-x_50 = lean_ctor_get_uint8(x_40, 7);
-x_51 = lean_ctor_get_uint8(x_40, 8);
-if (lean_is_exclusive(x_40)) {
- x_52 = x_40;
+x_45 = lean_ctor_get_uint8(x_41, 0);
+x_46 = lean_ctor_get_uint8(x_41, 1);
+x_47 = lean_ctor_get_uint8(x_41, 2);
+x_48 = lean_ctor_get_uint8(x_41, 3);
+x_49 = lean_ctor_get_uint8(x_41, 4);
+x_50 = lean_ctor_get_uint8(x_41, 6);
+x_51 = lean_ctor_get_uint8(x_41, 7);
+x_52 = lean_ctor_get_uint8(x_41, 8);
+x_53 = lean_ctor_get_uint8(x_41, 9);
+if (lean_is_exclusive(x_41)) {
+ x_54 = x_41;
 } else {
- lean_dec_ref(x_40);
- x_52 = lean_box(0);
+ lean_dec_ref(x_41);
+ x_54 = lean_box(0);
 }
-x_53 = 1;
-if (lean_is_scalar(x_52)) {
- x_54 = lean_alloc_ctor(0, 0, 9);
+x_55 = 1;
+if (lean_is_scalar(x_54)) {
+ x_56 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_54 = x_52;
+ x_56 = x_54;
 }
-lean_ctor_set_uint8(x_54, 0, x_44);
-lean_ctor_set_uint8(x_54, 1, x_45);
-lean_ctor_set_uint8(x_54, 2, x_46);
-lean_ctor_set_uint8(x_54, 3, x_47);
-lean_ctor_set_uint8(x_54, 4, x_48);
-lean_ctor_set_uint8(x_54, 5, x_53);
-lean_ctor_set_uint8(x_54, 6, x_49);
-lean_ctor_set_uint8(x_54, 7, x_50);
-lean_ctor_set_uint8(x_54, 8, x_51);
-x_55 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_41);
-lean_ctor_set(x_55, 2, x_42);
-lean_ctor_set(x_55, 3, x_43);
-x_56 = lean_apply_7(x_2, lean_box(0), x_1, x_55, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_56) == 0)
+lean_ctor_set_uint8(x_56, 0, x_45);
+lean_ctor_set_uint8(x_56, 1, x_46);
+lean_ctor_set_uint8(x_56, 2, x_47);
+lean_ctor_set_uint8(x_56, 3, x_48);
+lean_ctor_set_uint8(x_56, 4, x_49);
+lean_ctor_set_uint8(x_56, 5, x_55);
+lean_ctor_set_uint8(x_56, 6, x_50);
+lean_ctor_set_uint8(x_56, 7, x_51);
+lean_ctor_set_uint8(x_56, 8, x_52);
+lean_ctor_set_uint8(x_56, 9, x_53);
+x_57 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_57, 0, x_56);
+lean_ctor_set(x_57, 1, x_42);
+lean_ctor_set(x_57, 2, x_43);
+lean_ctor_set(x_57, 3, x_44);
+x_58 = lean_apply_7(x_2, lean_box(0), x_1, x_57, x_4, x_5, x_6, 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; 
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_56, 1);
-lean_inc(x_58);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_59 = x_56;
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_59 = lean_ctor_get(x_58, 0);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_58, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_61 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_59 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_61 = lean_box(0);
 }
-if (lean_is_scalar(x_59)) {
- x_60 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_61)) {
+ x_62 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_60 = x_59;
+ x_62 = x_61;
 }
-lean_ctor_set(x_60, 0, x_57);
-lean_ctor_set(x_60, 1, x_58);
-return x_60;
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_60);
+return x_62;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = lean_ctor_get(x_56, 0);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_56, 1);
-lean_inc(x_62);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_63 = x_56;
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_63 = lean_ctor_get(x_58, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_58, 1);
+lean_inc(x_64);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_65 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_63 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_65 = lean_box(0);
 }
-if (lean_is_scalar(x_63)) {
- x_64 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_65)) {
+ x_66 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_64 = x_63;
+ x_66 = x_65;
 }
-lean_ctor_set(x_64, 0, x_61);
-lean_ctor_set(x_64, 1, x_62);
-return x_64;
+lean_ctor_set(x_66, 0, x_63);
+lean_ctor_set(x_66, 1, x_64);
+return x_66;
 }
 }
 }
@@ -15628,7 +15782,7 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; 
 x_21 = lean_ctor_get_uint8(x_9, 0);
 x_22 = lean_ctor_get_uint8(x_9, 1);
 x_23 = lean_ctor_get_uint8(x_9, 2);
@@ -15637,164 +15791,168 @@ x_25 = lean_ctor_get_uint8(x_9, 4);
 x_26 = lean_ctor_get_uint8(x_9, 6);
 x_27 = lean_ctor_get_uint8(x_9, 7);
 x_28 = lean_ctor_get_uint8(x_9, 8);
+x_29 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_29 = 2;
-x_30 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_30, 0, x_21);
-lean_ctor_set_uint8(x_30, 1, x_22);
-lean_ctor_set_uint8(x_30, 2, x_23);
-lean_ctor_set_uint8(x_30, 3, x_24);
-lean_ctor_set_uint8(x_30, 4, x_25);
-lean_ctor_set_uint8(x_30, 5, x_29);
-lean_ctor_set_uint8(x_30, 6, x_26);
-lean_ctor_set_uint8(x_30, 7, x_27);
-lean_ctor_set_uint8(x_30, 8, x_28);
-lean_ctor_set(x_3, 0, x_30);
-x_31 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_31) == 0)
+x_30 = 2;
+x_31 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_31, 0, x_21);
+lean_ctor_set_uint8(x_31, 1, x_22);
+lean_ctor_set_uint8(x_31, 2, x_23);
+lean_ctor_set_uint8(x_31, 3, x_24);
+lean_ctor_set_uint8(x_31, 4, x_25);
+lean_ctor_set_uint8(x_31, 5, x_30);
+lean_ctor_set_uint8(x_31, 6, x_26);
+lean_ctor_set_uint8(x_31, 7, x_27);
+lean_ctor_set_uint8(x_31, 8, x_28);
+lean_ctor_set_uint8(x_31, 9, x_29);
+lean_ctor_set(x_3, 0, x_31);
+x_32 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_31, 0);
-lean_inc(x_32);
-x_33 = lean_ctor_get(x_31, 1);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_33 = lean_ctor_get(x_32, 0);
 lean_inc(x_33);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_34 = x_31;
+x_34 = lean_ctor_get(x_32, 1);
+lean_inc(x_34);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_35 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_34 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_35 = lean_box(0);
 }
-if (lean_is_scalar(x_34)) {
- x_35 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_35)) {
+ x_36 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_35 = x_34;
+ x_36 = x_35;
 }
-lean_ctor_set(x_35, 0, x_32);
-lean_ctor_set(x_35, 1, x_33);
-return x_35;
+lean_ctor_set(x_36, 0, x_33);
+lean_ctor_set(x_36, 1, x_34);
+return x_36;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_36 = lean_ctor_get(x_31, 0);
-lean_inc(x_36);
-x_37 = lean_ctor_get(x_31, 1);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_37 = lean_ctor_get(x_32, 0);
 lean_inc(x_37);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_38 = x_31;
+x_38 = lean_ctor_get(x_32, 1);
+lean_inc(x_38);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_39 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_38 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_39 = lean_box(0);
 }
-if (lean_is_scalar(x_38)) {
- x_39 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_39)) {
+ x_40 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_39 = x_38;
+ x_40 = x_39;
 }
-lean_ctor_set(x_39, 0, x_36);
-lean_ctor_set(x_39, 1, x_37);
-return x_39;
+lean_ctor_set(x_40, 0, x_37);
+lean_ctor_set(x_40, 1, x_38);
+return x_40;
 }
 }
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_40 = lean_ctor_get(x_3, 0);
-x_41 = lean_ctor_get(x_3, 1);
-x_42 = lean_ctor_get(x_3, 2);
-x_43 = lean_ctor_get(x_3, 3);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_41 = lean_ctor_get(x_3, 0);
+x_42 = lean_ctor_get(x_3, 1);
+x_43 = lean_ctor_get(x_3, 2);
+x_44 = lean_ctor_get(x_3, 3);
+lean_inc(x_44);
 lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
-lean_inc(x_40);
 lean_dec(x_3);
-x_44 = lean_ctor_get_uint8(x_40, 0);
-x_45 = lean_ctor_get_uint8(x_40, 1);
-x_46 = lean_ctor_get_uint8(x_40, 2);
-x_47 = lean_ctor_get_uint8(x_40, 3);
-x_48 = lean_ctor_get_uint8(x_40, 4);
-x_49 = lean_ctor_get_uint8(x_40, 6);
-x_50 = lean_ctor_get_uint8(x_40, 7);
-x_51 = lean_ctor_get_uint8(x_40, 8);
-if (lean_is_exclusive(x_40)) {
- x_52 = x_40;
+x_45 = lean_ctor_get_uint8(x_41, 0);
+x_46 = lean_ctor_get_uint8(x_41, 1);
+x_47 = lean_ctor_get_uint8(x_41, 2);
+x_48 = lean_ctor_get_uint8(x_41, 3);
+x_49 = lean_ctor_get_uint8(x_41, 4);
+x_50 = lean_ctor_get_uint8(x_41, 6);
+x_51 = lean_ctor_get_uint8(x_41, 7);
+x_52 = lean_ctor_get_uint8(x_41, 8);
+x_53 = lean_ctor_get_uint8(x_41, 9);
+if (lean_is_exclusive(x_41)) {
+ x_54 = x_41;
 } else {
- lean_dec_ref(x_40);
- x_52 = lean_box(0);
+ lean_dec_ref(x_41);
+ x_54 = lean_box(0);
 }
-x_53 = 2;
-if (lean_is_scalar(x_52)) {
- x_54 = lean_alloc_ctor(0, 0, 9);
+x_55 = 2;
+if (lean_is_scalar(x_54)) {
+ x_56 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_54 = x_52;
+ x_56 = x_54;
 }
-lean_ctor_set_uint8(x_54, 0, x_44);
-lean_ctor_set_uint8(x_54, 1, x_45);
-lean_ctor_set_uint8(x_54, 2, x_46);
-lean_ctor_set_uint8(x_54, 3, x_47);
-lean_ctor_set_uint8(x_54, 4, x_48);
-lean_ctor_set_uint8(x_54, 5, x_53);
-lean_ctor_set_uint8(x_54, 6, x_49);
-lean_ctor_set_uint8(x_54, 7, x_50);
-lean_ctor_set_uint8(x_54, 8, x_51);
-x_55 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_41);
-lean_ctor_set(x_55, 2, x_42);
-lean_ctor_set(x_55, 3, x_43);
-x_56 = lean_apply_7(x_2, lean_box(0), x_1, x_55, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_56) == 0)
+lean_ctor_set_uint8(x_56, 0, x_45);
+lean_ctor_set_uint8(x_56, 1, x_46);
+lean_ctor_set_uint8(x_56, 2, x_47);
+lean_ctor_set_uint8(x_56, 3, x_48);
+lean_ctor_set_uint8(x_56, 4, x_49);
+lean_ctor_set_uint8(x_56, 5, x_55);
+lean_ctor_set_uint8(x_56, 6, x_50);
+lean_ctor_set_uint8(x_56, 7, x_51);
+lean_ctor_set_uint8(x_56, 8, x_52);
+lean_ctor_set_uint8(x_56, 9, x_53);
+x_57 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_57, 0, x_56);
+lean_ctor_set(x_57, 1, x_42);
+lean_ctor_set(x_57, 2, x_43);
+lean_ctor_set(x_57, 3, x_44);
+x_58 = lean_apply_7(x_2, lean_box(0), x_1, x_57, x_4, x_5, x_6, 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; 
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_56, 1);
-lean_inc(x_58);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_59 = x_56;
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_59 = lean_ctor_get(x_58, 0);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_58, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_61 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_59 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_61 = lean_box(0);
 }
-if (lean_is_scalar(x_59)) {
- x_60 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_61)) {
+ x_62 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_60 = x_59;
+ x_62 = x_61;
 }
-lean_ctor_set(x_60, 0, x_57);
-lean_ctor_set(x_60, 1, x_58);
-return x_60;
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_60);
+return x_62;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = lean_ctor_get(x_56, 0);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_56, 1);
-lean_inc(x_62);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_63 = x_56;
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_63 = lean_ctor_get(x_58, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_58, 1);
+lean_inc(x_64);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_65 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_63 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_65 = lean_box(0);
 }
-if (lean_is_scalar(x_63)) {
- x_64 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_65)) {
+ x_66 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_64 = x_63;
+ x_66 = x_65;
 }
-lean_ctor_set(x_64, 0, x_61);
-lean_ctor_set(x_64, 1, x_62);
-return x_64;
+lean_ctor_set(x_66, 0, x_63);
+lean_ctor_set(x_66, 1, x_64);
+return x_66;
 }
 }
 }
@@ -15890,7 +16048,7 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; 
 x_21 = lean_ctor_get_uint8(x_9, 0);
 x_22 = lean_ctor_get_uint8(x_9, 1);
 x_23 = lean_ctor_get_uint8(x_9, 2);
@@ -15899,164 +16057,168 @@ x_25 = lean_ctor_get_uint8(x_9, 4);
 x_26 = lean_ctor_get_uint8(x_9, 6);
 x_27 = lean_ctor_get_uint8(x_9, 7);
 x_28 = lean_ctor_get_uint8(x_9, 8);
+x_29 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_29 = 3;
-x_30 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_30, 0, x_21);
-lean_ctor_set_uint8(x_30, 1, x_22);
-lean_ctor_set_uint8(x_30, 2, x_23);
-lean_ctor_set_uint8(x_30, 3, x_24);
-lean_ctor_set_uint8(x_30, 4, x_25);
-lean_ctor_set_uint8(x_30, 5, x_29);
-lean_ctor_set_uint8(x_30, 6, x_26);
-lean_ctor_set_uint8(x_30, 7, x_27);
-lean_ctor_set_uint8(x_30, 8, x_28);
-lean_ctor_set(x_3, 0, x_30);
-x_31 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_31) == 0)
+x_30 = 3;
+x_31 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_31, 0, x_21);
+lean_ctor_set_uint8(x_31, 1, x_22);
+lean_ctor_set_uint8(x_31, 2, x_23);
+lean_ctor_set_uint8(x_31, 3, x_24);
+lean_ctor_set_uint8(x_31, 4, x_25);
+lean_ctor_set_uint8(x_31, 5, x_30);
+lean_ctor_set_uint8(x_31, 6, x_26);
+lean_ctor_set_uint8(x_31, 7, x_27);
+lean_ctor_set_uint8(x_31, 8, x_28);
+lean_ctor_set_uint8(x_31, 9, x_29);
+lean_ctor_set(x_3, 0, x_31);
+x_32 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_31, 0);
-lean_inc(x_32);
-x_33 = lean_ctor_get(x_31, 1);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_33 = lean_ctor_get(x_32, 0);
 lean_inc(x_33);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_34 = x_31;
+x_34 = lean_ctor_get(x_32, 1);
+lean_inc(x_34);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_35 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_34 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_35 = lean_box(0);
 }
-if (lean_is_scalar(x_34)) {
- x_35 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_35)) {
+ x_36 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_35 = x_34;
+ x_36 = x_35;
 }
-lean_ctor_set(x_35, 0, x_32);
-lean_ctor_set(x_35, 1, x_33);
-return x_35;
+lean_ctor_set(x_36, 0, x_33);
+lean_ctor_set(x_36, 1, x_34);
+return x_36;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_36 = lean_ctor_get(x_31, 0);
-lean_inc(x_36);
-x_37 = lean_ctor_get(x_31, 1);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_37 = lean_ctor_get(x_32, 0);
 lean_inc(x_37);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_38 = x_31;
+x_38 = lean_ctor_get(x_32, 1);
+lean_inc(x_38);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_39 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_38 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_39 = lean_box(0);
 }
-if (lean_is_scalar(x_38)) {
- x_39 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_39)) {
+ x_40 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_39 = x_38;
+ x_40 = x_39;
 }
-lean_ctor_set(x_39, 0, x_36);
-lean_ctor_set(x_39, 1, x_37);
-return x_39;
+lean_ctor_set(x_40, 0, x_37);
+lean_ctor_set(x_40, 1, x_38);
+return x_40;
 }
 }
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_40 = lean_ctor_get(x_3, 0);
-x_41 = lean_ctor_get(x_3, 1);
-x_42 = lean_ctor_get(x_3, 2);
-x_43 = lean_ctor_get(x_3, 3);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_41 = lean_ctor_get(x_3, 0);
+x_42 = lean_ctor_get(x_3, 1);
+x_43 = lean_ctor_get(x_3, 2);
+x_44 = lean_ctor_get(x_3, 3);
+lean_inc(x_44);
 lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
-lean_inc(x_40);
 lean_dec(x_3);
-x_44 = lean_ctor_get_uint8(x_40, 0);
-x_45 = lean_ctor_get_uint8(x_40, 1);
-x_46 = lean_ctor_get_uint8(x_40, 2);
-x_47 = lean_ctor_get_uint8(x_40, 3);
-x_48 = lean_ctor_get_uint8(x_40, 4);
-x_49 = lean_ctor_get_uint8(x_40, 6);
-x_50 = lean_ctor_get_uint8(x_40, 7);
-x_51 = lean_ctor_get_uint8(x_40, 8);
-if (lean_is_exclusive(x_40)) {
- x_52 = x_40;
+x_45 = lean_ctor_get_uint8(x_41, 0);
+x_46 = lean_ctor_get_uint8(x_41, 1);
+x_47 = lean_ctor_get_uint8(x_41, 2);
+x_48 = lean_ctor_get_uint8(x_41, 3);
+x_49 = lean_ctor_get_uint8(x_41, 4);
+x_50 = lean_ctor_get_uint8(x_41, 6);
+x_51 = lean_ctor_get_uint8(x_41, 7);
+x_52 = lean_ctor_get_uint8(x_41, 8);
+x_53 = lean_ctor_get_uint8(x_41, 9);
+if (lean_is_exclusive(x_41)) {
+ x_54 = x_41;
 } else {
- lean_dec_ref(x_40);
- x_52 = lean_box(0);
+ lean_dec_ref(x_41);
+ x_54 = lean_box(0);
 }
-x_53 = 3;
-if (lean_is_scalar(x_52)) {
- x_54 = lean_alloc_ctor(0, 0, 9);
+x_55 = 3;
+if (lean_is_scalar(x_54)) {
+ x_56 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_54 = x_52;
+ x_56 = x_54;
 }
-lean_ctor_set_uint8(x_54, 0, x_44);
-lean_ctor_set_uint8(x_54, 1, x_45);
-lean_ctor_set_uint8(x_54, 2, x_46);
-lean_ctor_set_uint8(x_54, 3, x_47);
-lean_ctor_set_uint8(x_54, 4, x_48);
-lean_ctor_set_uint8(x_54, 5, x_53);
-lean_ctor_set_uint8(x_54, 6, x_49);
-lean_ctor_set_uint8(x_54, 7, x_50);
-lean_ctor_set_uint8(x_54, 8, x_51);
-x_55 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_41);
-lean_ctor_set(x_55, 2, x_42);
-lean_ctor_set(x_55, 3, x_43);
-x_56 = lean_apply_7(x_2, lean_box(0), x_1, x_55, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_56) == 0)
+lean_ctor_set_uint8(x_56, 0, x_45);
+lean_ctor_set_uint8(x_56, 1, x_46);
+lean_ctor_set_uint8(x_56, 2, x_47);
+lean_ctor_set_uint8(x_56, 3, x_48);
+lean_ctor_set_uint8(x_56, 4, x_49);
+lean_ctor_set_uint8(x_56, 5, x_55);
+lean_ctor_set_uint8(x_56, 6, x_50);
+lean_ctor_set_uint8(x_56, 7, x_51);
+lean_ctor_set_uint8(x_56, 8, x_52);
+lean_ctor_set_uint8(x_56, 9, x_53);
+x_57 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_57, 0, x_56);
+lean_ctor_set(x_57, 1, x_42);
+lean_ctor_set(x_57, 2, x_43);
+lean_ctor_set(x_57, 3, x_44);
+x_58 = lean_apply_7(x_2, lean_box(0), x_1, x_57, x_4, x_5, x_6, 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; 
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_56, 1);
-lean_inc(x_58);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_59 = x_56;
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_59 = lean_ctor_get(x_58, 0);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_58, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_61 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_59 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_61 = lean_box(0);
 }
-if (lean_is_scalar(x_59)) {
- x_60 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_61)) {
+ x_62 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_60 = x_59;
+ x_62 = x_61;
 }
-lean_ctor_set(x_60, 0, x_57);
-lean_ctor_set(x_60, 1, x_58);
-return x_60;
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_60);
+return x_62;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = lean_ctor_get(x_56, 0);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_56, 1);
-lean_inc(x_62);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_63 = x_56;
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_63 = lean_ctor_get(x_58, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_58, 1);
+lean_inc(x_64);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_65 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_63 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_65 = lean_box(0);
 }
-if (lean_is_scalar(x_63)) {
- x_64 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_65)) {
+ x_66 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_64 = x_63;
+ x_66 = x_65;
 }
-lean_ctor_set(x_64, 0, x_61);
-lean_ctor_set(x_64, 1, x_62);
-return x_64;
+lean_ctor_set(x_66, 0, x_63);
+lean_ctor_set(x_66, 1, x_64);
+return x_66;
 }
 }
 }
@@ -16120,7 +16282,7 @@ return x_15;
 }
 else
 {
-uint8_t x_16; uint8_t x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; 
+uint8_t x_16; uint8_t x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; 
 x_16 = lean_ctor_get_uint8(x_10, 0);
 x_17 = lean_ctor_get_uint8(x_10, 1);
 x_18 = lean_ctor_get_uint8(x_10, 2);
@@ -16130,121 +16292,127 @@ x_21 = lean_ctor_get_uint8(x_10, 5);
 x_22 = lean_ctor_get_uint8(x_10, 6);
 x_23 = lean_ctor_get_uint8(x_10, 7);
 x_24 = lean_ctor_get_uint8(x_10, 8);
+x_25 = lean_ctor_get_uint8(x_10, 9);
 lean_dec(x_10);
-x_25 = l_Lean_Meta_TransparencyMode_lt(x_21, x_1);
-if (x_25 == 0)
+x_26 = l_Lean_Meta_TransparencyMode_lt(x_21, x_1);
+if (x_26 == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_26, 0, x_16);
-lean_ctor_set_uint8(x_26, 1, x_17);
-lean_ctor_set_uint8(x_26, 2, x_18);
-lean_ctor_set_uint8(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, 4, x_20);
-lean_ctor_set_uint8(x_26, 5, x_21);
-lean_ctor_set_uint8(x_26, 6, x_22);
-lean_ctor_set_uint8(x_26, 7, x_23);
-lean_ctor_set_uint8(x_26, 8, x_24);
-lean_ctor_set(x_4, 0, x_26);
-x_27 = lean_apply_7(x_3, lean_box(0), x_2, x_4, x_5, x_6, x_7, x_8);
-return x_27;
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_27, 0, x_16);
+lean_ctor_set_uint8(x_27, 1, x_17);
+lean_ctor_set_uint8(x_27, 2, x_18);
+lean_ctor_set_uint8(x_27, 3, x_19);
+lean_ctor_set_uint8(x_27, 4, x_20);
+lean_ctor_set_uint8(x_27, 5, x_21);
+lean_ctor_set_uint8(x_27, 6, x_22);
+lean_ctor_set_uint8(x_27, 7, x_23);
+lean_ctor_set_uint8(x_27, 8, x_24);
+lean_ctor_set_uint8(x_27, 9, x_25);
+lean_ctor_set(x_4, 0, x_27);
+x_28 = lean_apply_7(x_3, lean_box(0), x_2, x_4, x_5, x_6, x_7, x_8);
+return x_28;
 }
 else
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_28, 0, x_16);
-lean_ctor_set_uint8(x_28, 1, x_17);
-lean_ctor_set_uint8(x_28, 2, x_18);
-lean_ctor_set_uint8(x_28, 3, x_19);
-lean_ctor_set_uint8(x_28, 4, x_20);
-lean_ctor_set_uint8(x_28, 5, x_1);
-lean_ctor_set_uint8(x_28, 6, x_22);
-lean_ctor_set_uint8(x_28, 7, x_23);
-lean_ctor_set_uint8(x_28, 8, x_24);
-lean_ctor_set(x_4, 0, x_28);
-x_29 = lean_apply_7(x_3, lean_box(0), x_2, x_4, x_5, x_6, x_7, x_8);
-return x_29;
+lean_object* x_29; lean_object* x_30; 
+x_29 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_29, 0, x_16);
+lean_ctor_set_uint8(x_29, 1, x_17);
+lean_ctor_set_uint8(x_29, 2, x_18);
+lean_ctor_set_uint8(x_29, 3, x_19);
+lean_ctor_set_uint8(x_29, 4, x_20);
+lean_ctor_set_uint8(x_29, 5, x_1);
+lean_ctor_set_uint8(x_29, 6, x_22);
+lean_ctor_set_uint8(x_29, 7, x_23);
+lean_ctor_set_uint8(x_29, 8, x_24);
+lean_ctor_set_uint8(x_29, 9, x_25);
+lean_ctor_set(x_4, 0, x_29);
+x_30 = lean_apply_7(x_3, lean_box(0), x_2, x_4, x_5, x_6, x_7, x_8);
+return x_30;
 }
 }
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* 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; uint8_t x_42; lean_object* x_43; uint8_t x_44; 
-x_30 = lean_ctor_get(x_4, 0);
-x_31 = lean_ctor_get(x_4, 1);
-x_32 = lean_ctor_get(x_4, 2);
-x_33 = lean_ctor_get(x_4, 3);
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* 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; uint8_t x_42; uint8_t x_43; uint8_t x_44; lean_object* x_45; uint8_t x_46; 
+x_31 = lean_ctor_get(x_4, 0);
+x_32 = lean_ctor_get(x_4, 1);
+x_33 = lean_ctor_get(x_4, 2);
+x_34 = lean_ctor_get(x_4, 3);
+lean_inc(x_34);
 lean_inc(x_33);
 lean_inc(x_32);
 lean_inc(x_31);
-lean_inc(x_30);
 lean_dec(x_4);
-x_34 = lean_ctor_get_uint8(x_30, 0);
-x_35 = lean_ctor_get_uint8(x_30, 1);
-x_36 = lean_ctor_get_uint8(x_30, 2);
-x_37 = lean_ctor_get_uint8(x_30, 3);
-x_38 = lean_ctor_get_uint8(x_30, 4);
-x_39 = lean_ctor_get_uint8(x_30, 5);
-x_40 = lean_ctor_get_uint8(x_30, 6);
-x_41 = lean_ctor_get_uint8(x_30, 7);
-x_42 = lean_ctor_get_uint8(x_30, 8);
-if (lean_is_exclusive(x_30)) {
- x_43 = x_30;
+x_35 = lean_ctor_get_uint8(x_31, 0);
+x_36 = lean_ctor_get_uint8(x_31, 1);
+x_37 = lean_ctor_get_uint8(x_31, 2);
+x_38 = lean_ctor_get_uint8(x_31, 3);
+x_39 = lean_ctor_get_uint8(x_31, 4);
+x_40 = lean_ctor_get_uint8(x_31, 5);
+x_41 = lean_ctor_get_uint8(x_31, 6);
+x_42 = lean_ctor_get_uint8(x_31, 7);
+x_43 = lean_ctor_get_uint8(x_31, 8);
+x_44 = lean_ctor_get_uint8(x_31, 9);
+if (lean_is_exclusive(x_31)) {
+ x_45 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_43 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_45 = lean_box(0);
 }
-x_44 = l_Lean_Meta_TransparencyMode_lt(x_39, x_1);
-if (x_44 == 0)
+x_46 = l_Lean_Meta_TransparencyMode_lt(x_40, x_1);
+if (x_46 == 0)
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-if (lean_is_scalar(x_43)) {
- x_45 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+if (lean_is_scalar(x_45)) {
+ x_47 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_45 = x_43;
+ x_47 = x_45;
 }
-lean_ctor_set_uint8(x_45, 0, x_34);
-lean_ctor_set_uint8(x_45, 1, x_35);
-lean_ctor_set_uint8(x_45, 2, x_36);
-lean_ctor_set_uint8(x_45, 3, x_37);
-lean_ctor_set_uint8(x_45, 4, x_38);
-lean_ctor_set_uint8(x_45, 5, x_39);
-lean_ctor_set_uint8(x_45, 6, x_40);
-lean_ctor_set_uint8(x_45, 7, x_41);
-lean_ctor_set_uint8(x_45, 8, x_42);
-x_46 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_46, 0, x_45);
-lean_ctor_set(x_46, 1, x_31);
-lean_ctor_set(x_46, 2, x_32);
-lean_ctor_set(x_46, 3, x_33);
-x_47 = lean_apply_7(x_3, lean_box(0), x_2, x_46, x_5, x_6, x_7, x_8);
-return x_47;
+lean_ctor_set_uint8(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, 1, x_36);
+lean_ctor_set_uint8(x_47, 2, x_37);
+lean_ctor_set_uint8(x_47, 3, x_38);
+lean_ctor_set_uint8(x_47, 4, x_39);
+lean_ctor_set_uint8(x_47, 5, x_40);
+lean_ctor_set_uint8(x_47, 6, x_41);
+lean_ctor_set_uint8(x_47, 7, x_42);
+lean_ctor_set_uint8(x_47, 8, x_43);
+lean_ctor_set_uint8(x_47, 9, x_44);
+x_48 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_48, 0, x_47);
+lean_ctor_set(x_48, 1, x_32);
+lean_ctor_set(x_48, 2, x_33);
+lean_ctor_set(x_48, 3, x_34);
+x_49 = lean_apply_7(x_3, lean_box(0), x_2, x_48, x_5, x_6, x_7, x_8);
+return x_49;
 }
 else
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-if (lean_is_scalar(x_43)) {
- x_48 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+if (lean_is_scalar(x_45)) {
+ x_50 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_48 = x_43;
+ x_50 = x_45;
 }
-lean_ctor_set_uint8(x_48, 0, x_34);
-lean_ctor_set_uint8(x_48, 1, x_35);
-lean_ctor_set_uint8(x_48, 2, x_36);
-lean_ctor_set_uint8(x_48, 3, x_37);
-lean_ctor_set_uint8(x_48, 4, x_38);
-lean_ctor_set_uint8(x_48, 5, x_1);
-lean_ctor_set_uint8(x_48, 6, x_40);
-lean_ctor_set_uint8(x_48, 7, x_41);
-lean_ctor_set_uint8(x_48, 8, x_42);
-x_49 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_31);
-lean_ctor_set(x_49, 2, x_32);
-lean_ctor_set(x_49, 3, x_33);
-x_50 = lean_apply_7(x_3, lean_box(0), x_2, x_49, x_5, x_6, x_7, x_8);
-return x_50;
+lean_ctor_set_uint8(x_50, 0, x_35);
+lean_ctor_set_uint8(x_50, 1, x_36);
+lean_ctor_set_uint8(x_50, 2, x_37);
+lean_ctor_set_uint8(x_50, 3, x_38);
+lean_ctor_set_uint8(x_50, 4, x_39);
+lean_ctor_set_uint8(x_50, 5, x_1);
+lean_ctor_set_uint8(x_50, 6, x_41);
+lean_ctor_set_uint8(x_50, 7, x_42);
+lean_ctor_set_uint8(x_50, 8, x_43);
+lean_ctor_set_uint8(x_50, 9, x_44);
+x_51 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_51, 0, x_50);
+lean_ctor_set(x_51, 1, x_32);
+lean_ctor_set(x_51, 2, x_33);
+lean_ctor_set(x_51, 3, x_34);
+x_52 = lean_apply_7(x_3, lean_box(0), x_2, x_51, x_5, x_6, x_7, x_8);
+return x_52;
 }
 }
 }
@@ -20396,7 +20564,7 @@ return x_21;
 }
 else
 {
-uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
 x_22 = lean_ctor_get_uint8(x_9, 0);
 x_23 = lean_ctor_get_uint8(x_9, 1);
 x_24 = lean_ctor_get_uint8(x_9, 2);
@@ -20405,166 +20573,170 @@ x_26 = lean_ctor_get_uint8(x_9, 4);
 x_27 = lean_ctor_get_uint8(x_9, 6);
 x_28 = lean_ctor_get_uint8(x_9, 7);
 x_29 = lean_ctor_get_uint8(x_9, 8);
+x_30 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_30 = 2;
-x_31 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_31, 0, x_22);
-lean_ctor_set_uint8(x_31, 1, x_23);
-lean_ctor_set_uint8(x_31, 2, x_24);
-lean_ctor_set_uint8(x_31, 3, x_25);
-lean_ctor_set_uint8(x_31, 4, x_26);
-lean_ctor_set_uint8(x_31, 5, x_30);
-lean_ctor_set_uint8(x_31, 6, x_27);
-lean_ctor_set_uint8(x_31, 7, x_28);
-lean_ctor_set_uint8(x_31, 8, x_29);
-lean_ctor_set(x_2, 0, x_31);
-x_32 = l___private_Lean_Meta_Basic_0__Lean_Meta_isClassExpensive_x3f___closed__1;
-x_33 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux___rarg(x_1, x_7, x_32, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_33) == 0)
+x_31 = 2;
+x_32 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_32, 0, x_22);
+lean_ctor_set_uint8(x_32, 1, x_23);
+lean_ctor_set_uint8(x_32, 2, x_24);
+lean_ctor_set_uint8(x_32, 3, x_25);
+lean_ctor_set_uint8(x_32, 4, x_26);
+lean_ctor_set_uint8(x_32, 5, x_31);
+lean_ctor_set_uint8(x_32, 6, x_27);
+lean_ctor_set_uint8(x_32, 7, x_28);
+lean_ctor_set_uint8(x_32, 8, x_29);
+lean_ctor_set_uint8(x_32, 9, x_30);
+lean_ctor_set(x_2, 0, x_32);
+x_33 = l___private_Lean_Meta_Basic_0__Lean_Meta_isClassExpensive_x3f___closed__1;
+x_34 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux___rarg(x_1, x_7, x_33, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_34 = lean_ctor_get(x_33, 0);
-lean_inc(x_34);
-x_35 = lean_ctor_get(x_33, 1);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+x_35 = lean_ctor_get(x_34, 0);
 lean_inc(x_35);
-if (lean_is_exclusive(x_33)) {
- lean_ctor_release(x_33, 0);
- lean_ctor_release(x_33, 1);
- x_36 = x_33;
+x_36 = lean_ctor_get(x_34, 1);
+lean_inc(x_36);
+if (lean_is_exclusive(x_34)) {
+ lean_ctor_release(x_34, 0);
+ lean_ctor_release(x_34, 1);
+ x_37 = x_34;
 } else {
- lean_dec_ref(x_33);
- x_36 = lean_box(0);
+ lean_dec_ref(x_34);
+ x_37 = lean_box(0);
 }
-if (lean_is_scalar(x_36)) {
- x_37 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_37)) {
+ x_38 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_37 = x_36;
+ x_38 = x_37;
 }
-lean_ctor_set(x_37, 0, x_34);
-lean_ctor_set(x_37, 1, x_35);
-return x_37;
+lean_ctor_set(x_38, 0, x_35);
+lean_ctor_set(x_38, 1, x_36);
+return x_38;
 }
 else
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_38 = lean_ctor_get(x_33, 0);
-lean_inc(x_38);
-x_39 = lean_ctor_get(x_33, 1);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_39 = lean_ctor_get(x_34, 0);
 lean_inc(x_39);
-if (lean_is_exclusive(x_33)) {
- lean_ctor_release(x_33, 0);
- lean_ctor_release(x_33, 1);
- x_40 = x_33;
+x_40 = lean_ctor_get(x_34, 1);
+lean_inc(x_40);
+if (lean_is_exclusive(x_34)) {
+ lean_ctor_release(x_34, 0);
+ lean_ctor_release(x_34, 1);
+ x_41 = x_34;
 } else {
- lean_dec_ref(x_33);
- x_40 = lean_box(0);
+ lean_dec_ref(x_34);
+ x_41 = lean_box(0);
 }
-if (lean_is_scalar(x_40)) {
- x_41 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_41)) {
+ x_42 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_41 = x_40;
+ x_42 = x_41;
 }
-lean_ctor_set(x_41, 0, x_38);
-lean_ctor_set(x_41, 1, x_39);
-return x_41;
+lean_ctor_set(x_42, 0, x_39);
+lean_ctor_set(x_42, 1, x_40);
+return x_42;
 }
 }
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_42 = lean_ctor_get(x_2, 0);
-x_43 = lean_ctor_get(x_2, 1);
-x_44 = lean_ctor_get(x_2, 2);
-x_45 = lean_ctor_get(x_2, 3);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_43 = lean_ctor_get(x_2, 0);
+x_44 = lean_ctor_get(x_2, 1);
+x_45 = lean_ctor_get(x_2, 2);
+x_46 = lean_ctor_get(x_2, 3);
+lean_inc(x_46);
 lean_inc(x_45);
 lean_inc(x_44);
 lean_inc(x_43);
-lean_inc(x_42);
 lean_dec(x_2);
-x_46 = lean_ctor_get_uint8(x_42, 0);
-x_47 = lean_ctor_get_uint8(x_42, 1);
-x_48 = lean_ctor_get_uint8(x_42, 2);
-x_49 = lean_ctor_get_uint8(x_42, 3);
-x_50 = lean_ctor_get_uint8(x_42, 4);
-x_51 = lean_ctor_get_uint8(x_42, 6);
-x_52 = lean_ctor_get_uint8(x_42, 7);
-x_53 = lean_ctor_get_uint8(x_42, 8);
-if (lean_is_exclusive(x_42)) {
- x_54 = x_42;
+x_47 = lean_ctor_get_uint8(x_43, 0);
+x_48 = lean_ctor_get_uint8(x_43, 1);
+x_49 = lean_ctor_get_uint8(x_43, 2);
+x_50 = lean_ctor_get_uint8(x_43, 3);
+x_51 = lean_ctor_get_uint8(x_43, 4);
+x_52 = lean_ctor_get_uint8(x_43, 6);
+x_53 = lean_ctor_get_uint8(x_43, 7);
+x_54 = lean_ctor_get_uint8(x_43, 8);
+x_55 = lean_ctor_get_uint8(x_43, 9);
+if (lean_is_exclusive(x_43)) {
+ x_56 = x_43;
 } else {
- lean_dec_ref(x_42);
- x_54 = lean_box(0);
+ lean_dec_ref(x_43);
+ x_56 = lean_box(0);
 }
-x_55 = 2;
-if (lean_is_scalar(x_54)) {
- x_56 = lean_alloc_ctor(0, 0, 9);
+x_57 = 2;
+if (lean_is_scalar(x_56)) {
+ x_58 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_56 = x_54;
+ x_58 = x_56;
 }
-lean_ctor_set_uint8(x_56, 0, x_46);
-lean_ctor_set_uint8(x_56, 1, x_47);
-lean_ctor_set_uint8(x_56, 2, x_48);
-lean_ctor_set_uint8(x_56, 3, x_49);
-lean_ctor_set_uint8(x_56, 4, x_50);
-lean_ctor_set_uint8(x_56, 5, x_55);
-lean_ctor_set_uint8(x_56, 6, x_51);
-lean_ctor_set_uint8(x_56, 7, x_52);
-lean_ctor_set_uint8(x_56, 8, x_53);
-x_57 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_57, 0, x_56);
-lean_ctor_set(x_57, 1, x_43);
-lean_ctor_set(x_57, 2, x_44);
-lean_ctor_set(x_57, 3, x_45);
-x_58 = l___private_Lean_Meta_Basic_0__Lean_Meta_isClassExpensive_x3f___closed__1;
-x_59 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux___rarg(x_1, x_7, x_58, x_57, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_59) == 0)
+lean_ctor_set_uint8(x_58, 0, x_47);
+lean_ctor_set_uint8(x_58, 1, x_48);
+lean_ctor_set_uint8(x_58, 2, x_49);
+lean_ctor_set_uint8(x_58, 3, x_50);
+lean_ctor_set_uint8(x_58, 4, x_51);
+lean_ctor_set_uint8(x_58, 5, x_57);
+lean_ctor_set_uint8(x_58, 6, x_52);
+lean_ctor_set_uint8(x_58, 7, x_53);
+lean_ctor_set_uint8(x_58, 8, x_54);
+lean_ctor_set_uint8(x_58, 9, x_55);
+x_59 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_59, 0, x_58);
+lean_ctor_set(x_59, 1, x_44);
+lean_ctor_set(x_59, 2, x_45);
+lean_ctor_set(x_59, 3, x_46);
+x_60 = l___private_Lean_Meta_Basic_0__Lean_Meta_isClassExpensive_x3f___closed__1;
+x_61 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux___rarg(x_1, x_7, x_60, x_59, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_61) == 0)
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_59, 1);
-lean_inc(x_61);
-if (lean_is_exclusive(x_59)) {
- lean_ctor_release(x_59, 0);
- lean_ctor_release(x_59, 1);
- x_62 = x_59;
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_62 = lean_ctor_get(x_61, 0);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_61, 1);
+lean_inc(x_63);
+if (lean_is_exclusive(x_61)) {
+ lean_ctor_release(x_61, 0);
+ lean_ctor_release(x_61, 1);
+ x_64 = x_61;
 } else {
- lean_dec_ref(x_59);
- x_62 = lean_box(0);
+ lean_dec_ref(x_61);
+ x_64 = lean_box(0);
 }
-if (lean_is_scalar(x_62)) {
- x_63 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_64)) {
+ x_65 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_63 = x_62;
+ x_65 = x_64;
 }
-lean_ctor_set(x_63, 0, x_60);
-lean_ctor_set(x_63, 1, x_61);
-return x_63;
+lean_ctor_set(x_65, 0, x_62);
+lean_ctor_set(x_65, 1, x_63);
+return x_65;
 }
 else
 {
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_64 = lean_ctor_get(x_59, 0);
-lean_inc(x_64);
-x_65 = lean_ctor_get(x_59, 1);
-lean_inc(x_65);
-if (lean_is_exclusive(x_59)) {
- lean_ctor_release(x_59, 0);
- lean_ctor_release(x_59, 1);
- x_66 = x_59;
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_66 = lean_ctor_get(x_61, 0);
+lean_inc(x_66);
+x_67 = lean_ctor_get(x_61, 1);
+lean_inc(x_67);
+if (lean_is_exclusive(x_61)) {
+ lean_ctor_release(x_61, 0);
+ lean_ctor_release(x_61, 1);
+ x_68 = x_61;
 } else {
- lean_dec_ref(x_59);
- x_66 = lean_box(0);
+ lean_dec_ref(x_61);
+ x_68 = lean_box(0);
 }
-if (lean_is_scalar(x_66)) {
- x_67 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_68)) {
+ x_69 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_67 = x_66;
+ x_69 = x_68;
 }
-lean_ctor_set(x_67, 0, x_64);
-lean_ctor_set(x_67, 1, x_65);
-return x_67;
+lean_ctor_set(x_69, 0, x_66);
+lean_ctor_set(x_69, 1, x_67);
+return x_69;
 }
 }
 }
@@ -25531,169 +25703,173 @@ return x_19;
 }
 else
 {
-uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; 
+uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; 
 x_20 = lean_ctor_get_uint8(x_8, 3);
 x_21 = lean_ctor_get_uint8(x_8, 4);
 x_22 = lean_ctor_get_uint8(x_8, 5);
 x_23 = lean_ctor_get_uint8(x_8, 6);
 x_24 = lean_ctor_get_uint8(x_8, 7);
 x_25 = lean_ctor_get_uint8(x_8, 8);
+x_26 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_26 = 1;
-x_27 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_27, 0, x_26);
-lean_ctor_set_uint8(x_27, 1, x_26);
-lean_ctor_set_uint8(x_27, 2, x_26);
-lean_ctor_set_uint8(x_27, 3, x_20);
-lean_ctor_set_uint8(x_27, 4, x_21);
-lean_ctor_set_uint8(x_27, 5, x_22);
-lean_ctor_set_uint8(x_27, 6, x_23);
-lean_ctor_set_uint8(x_27, 7, x_24);
-lean_ctor_set_uint8(x_27, 8, x_25);
-lean_ctor_set(x_2, 0, x_27);
-x_28 = lean_apply_5(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_28) == 0)
+x_27 = 1;
+x_28 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_28, 0, x_27);
+lean_ctor_set_uint8(x_28, 1, x_27);
+lean_ctor_set_uint8(x_28, 2, x_27);
+lean_ctor_set_uint8(x_28, 3, x_20);
+lean_ctor_set_uint8(x_28, 4, x_21);
+lean_ctor_set_uint8(x_28, 5, x_22);
+lean_ctor_set_uint8(x_28, 6, x_23);
+lean_ctor_set_uint8(x_28, 7, x_24);
+lean_ctor_set_uint8(x_28, 8, x_25);
+lean_ctor_set_uint8(x_28, 9, x_26);
+lean_ctor_set(x_2, 0, x_28);
+x_29 = lean_apply_5(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = lean_ctor_get(x_28, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_28, 1);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
-if (lean_is_exclusive(x_28)) {
- lean_ctor_release(x_28, 0);
- lean_ctor_release(x_28, 1);
- x_31 = x_28;
+x_31 = lean_ctor_get(x_29, 1);
+lean_inc(x_31);
+if (lean_is_exclusive(x_29)) {
+ lean_ctor_release(x_29, 0);
+ lean_ctor_release(x_29, 1);
+ x_32 = x_29;
 } else {
- lean_dec_ref(x_28);
- x_31 = lean_box(0);
+ lean_dec_ref(x_29);
+ x_32 = lean_box(0);
 }
-if (lean_is_scalar(x_31)) {
- x_32 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_32)) {
+ x_33 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_32 = x_31;
+ x_33 = x_32;
 }
-lean_ctor_set(x_32, 0, x_29);
-lean_ctor_set(x_32, 1, x_30);
-return x_32;
+lean_ctor_set(x_33, 0, x_30);
+lean_ctor_set(x_33, 1, x_31);
+return x_33;
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_33 = lean_ctor_get(x_28, 0);
-lean_inc(x_33);
-x_34 = lean_ctor_get(x_28, 1);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_34 = lean_ctor_get(x_29, 0);
 lean_inc(x_34);
-if (lean_is_exclusive(x_28)) {
- lean_ctor_release(x_28, 0);
- lean_ctor_release(x_28, 1);
- x_35 = x_28;
+x_35 = lean_ctor_get(x_29, 1);
+lean_inc(x_35);
+if (lean_is_exclusive(x_29)) {
+ lean_ctor_release(x_29, 0);
+ lean_ctor_release(x_29, 1);
+ x_36 = x_29;
 } else {
- lean_dec_ref(x_28);
- x_35 = lean_box(0);
+ lean_dec_ref(x_29);
+ x_36 = lean_box(0);
 }
-if (lean_is_scalar(x_35)) {
- x_36 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_36)) {
+ x_37 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_36 = x_35;
+ x_37 = x_36;
 }
-lean_ctor_set(x_36, 0, x_33);
-lean_ctor_set(x_36, 1, x_34);
-return x_36;
+lean_ctor_set(x_37, 0, x_34);
+lean_ctor_set(x_37, 1, x_35);
+return x_37;
 }
 }
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-x_37 = lean_ctor_get(x_2, 0);
-x_38 = lean_ctor_get(x_2, 1);
-x_39 = lean_ctor_get(x_2, 2);
-x_40 = lean_ctor_get(x_2, 3);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; lean_object* x_49; uint8_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_38 = lean_ctor_get(x_2, 0);
+x_39 = lean_ctor_get(x_2, 1);
+x_40 = lean_ctor_get(x_2, 2);
+x_41 = lean_ctor_get(x_2, 3);
+lean_inc(x_41);
 lean_inc(x_40);
 lean_inc(x_39);
 lean_inc(x_38);
-lean_inc(x_37);
 lean_dec(x_2);
-x_41 = lean_ctor_get_uint8(x_37, 3);
-x_42 = lean_ctor_get_uint8(x_37, 4);
-x_43 = lean_ctor_get_uint8(x_37, 5);
-x_44 = lean_ctor_get_uint8(x_37, 6);
-x_45 = lean_ctor_get_uint8(x_37, 7);
-x_46 = lean_ctor_get_uint8(x_37, 8);
-if (lean_is_exclusive(x_37)) {
- x_47 = x_37;
+x_42 = lean_ctor_get_uint8(x_38, 3);
+x_43 = lean_ctor_get_uint8(x_38, 4);
+x_44 = lean_ctor_get_uint8(x_38, 5);
+x_45 = lean_ctor_get_uint8(x_38, 6);
+x_46 = lean_ctor_get_uint8(x_38, 7);
+x_47 = lean_ctor_get_uint8(x_38, 8);
+x_48 = lean_ctor_get_uint8(x_38, 9);
+if (lean_is_exclusive(x_38)) {
+ x_49 = x_38;
 } else {
- lean_dec_ref(x_37);
- x_47 = lean_box(0);
+ lean_dec_ref(x_38);
+ x_49 = lean_box(0);
 }
-x_48 = 1;
-if (lean_is_scalar(x_47)) {
- x_49 = lean_alloc_ctor(0, 0, 9);
+x_50 = 1;
+if (lean_is_scalar(x_49)) {
+ x_51 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_49 = x_47;
+ x_51 = x_49;
 }
-lean_ctor_set_uint8(x_49, 0, x_48);
-lean_ctor_set_uint8(x_49, 1, x_48);
-lean_ctor_set_uint8(x_49, 2, x_48);
-lean_ctor_set_uint8(x_49, 3, x_41);
-lean_ctor_set_uint8(x_49, 4, x_42);
-lean_ctor_set_uint8(x_49, 5, x_43);
-lean_ctor_set_uint8(x_49, 6, x_44);
-lean_ctor_set_uint8(x_49, 7, x_45);
-lean_ctor_set_uint8(x_49, 8, x_46);
-x_50 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_50, 1, x_38);
-lean_ctor_set(x_50, 2, x_39);
-lean_ctor_set(x_50, 3, x_40);
-x_51 = lean_apply_5(x_1, x_50, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_51) == 0)
+lean_ctor_set_uint8(x_51, 0, x_50);
+lean_ctor_set_uint8(x_51, 1, x_50);
+lean_ctor_set_uint8(x_51, 2, x_50);
+lean_ctor_set_uint8(x_51, 3, x_42);
+lean_ctor_set_uint8(x_51, 4, x_43);
+lean_ctor_set_uint8(x_51, 5, x_44);
+lean_ctor_set_uint8(x_51, 6, x_45);
+lean_ctor_set_uint8(x_51, 7, x_46);
+lean_ctor_set_uint8(x_51, 8, x_47);
+lean_ctor_set_uint8(x_51, 9, x_48);
+x_52 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_52, 0, x_51);
+lean_ctor_set(x_52, 1, x_39);
+lean_ctor_set(x_52, 2, x_40);
+lean_ctor_set(x_52, 3, x_41);
+x_53 = lean_apply_5(x_1, x_52, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_53) == 0)
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_52 = lean_ctor_get(x_51, 0);
-lean_inc(x_52);
-x_53 = lean_ctor_get(x_51, 1);
-lean_inc(x_53);
-if (lean_is_exclusive(x_51)) {
- lean_ctor_release(x_51, 0);
- lean_ctor_release(x_51, 1);
- x_54 = x_51;
+lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_54 = lean_ctor_get(x_53, 0);
+lean_inc(x_54);
+x_55 = lean_ctor_get(x_53, 1);
+lean_inc(x_55);
+if (lean_is_exclusive(x_53)) {
+ lean_ctor_release(x_53, 0);
+ lean_ctor_release(x_53, 1);
+ x_56 = x_53;
 } else {
- lean_dec_ref(x_51);
- x_54 = lean_box(0);
+ lean_dec_ref(x_53);
+ x_56 = lean_box(0);
 }
-if (lean_is_scalar(x_54)) {
- x_55 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_56)) {
+ x_57 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_55 = x_54;
+ x_57 = x_56;
 }
-lean_ctor_set(x_55, 0, x_52);
-lean_ctor_set(x_55, 1, x_53);
-return x_55;
+lean_ctor_set(x_57, 0, x_54);
+lean_ctor_set(x_57, 1, x_55);
+return x_57;
 }
 else
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = lean_ctor_get(x_51, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_51, 1);
-lean_inc(x_57);
-if (lean_is_exclusive(x_51)) {
- lean_ctor_release(x_51, 0);
- lean_ctor_release(x_51, 1);
- x_58 = x_51;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_58 = lean_ctor_get(x_53, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_53, 1);
+lean_inc(x_59);
+if (lean_is_exclusive(x_53)) {
+ lean_ctor_release(x_53, 0);
+ lean_ctor_release(x_53, 1);
+ x_60 = x_53;
 } else {
- lean_dec_ref(x_51);
- x_58 = lean_box(0);
+ lean_dec_ref(x_53);
+ x_60 = lean_box(0);
 }
-if (lean_is_scalar(x_58)) {
- x_59 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_60)) {
+ x_61 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_59 = x_58;
+ x_61 = x_60;
 }
-lean_ctor_set(x_59, 0, x_56);
-lean_ctor_set(x_59, 1, x_57);
-return x_59;
+lean_ctor_set(x_61, 0, x_58);
+lean_ctor_set(x_61, 1, x_59);
+return x_61;
 }
 }
 }
@@ -25771,169 +25947,173 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
 x_21 = lean_ctor_get_uint8(x_9, 3);
 x_22 = lean_ctor_get_uint8(x_9, 4);
 x_23 = lean_ctor_get_uint8(x_9, 5);
 x_24 = lean_ctor_get_uint8(x_9, 6);
 x_25 = lean_ctor_get_uint8(x_9, 7);
 x_26 = lean_ctor_get_uint8(x_9, 8);
+x_27 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_27 = 1;
-x_28 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_28, 0, x_27);
-lean_ctor_set_uint8(x_28, 1, x_27);
-lean_ctor_set_uint8(x_28, 2, x_27);
-lean_ctor_set_uint8(x_28, 3, x_21);
-lean_ctor_set_uint8(x_28, 4, x_22);
-lean_ctor_set_uint8(x_28, 5, x_23);
-lean_ctor_set_uint8(x_28, 6, x_24);
-lean_ctor_set_uint8(x_28, 7, x_25);
-lean_ctor_set_uint8(x_28, 8, x_26);
-lean_ctor_set(x_3, 0, x_28);
-x_29 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_29) == 0)
+x_28 = 1;
+x_29 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_29, 0, x_28);
+lean_ctor_set_uint8(x_29, 1, x_28);
+lean_ctor_set_uint8(x_29, 2, x_28);
+lean_ctor_set_uint8(x_29, 3, x_21);
+lean_ctor_set_uint8(x_29, 4, x_22);
+lean_ctor_set_uint8(x_29, 5, x_23);
+lean_ctor_set_uint8(x_29, 6, x_24);
+lean_ctor_set_uint8(x_29, 7, x_25);
+lean_ctor_set_uint8(x_29, 8, x_26);
+lean_ctor_set_uint8(x_29, 9, x_27);
+lean_ctor_set(x_3, 0, x_29);
+x_30 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_30; lean_object* x_31; lean_object* 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_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
-if (lean_is_exclusive(x_29)) {
- lean_ctor_release(x_29, 0);
- lean_ctor_release(x_29, 1);
- x_32 = x_29;
+x_32 = lean_ctor_get(x_30, 1);
+lean_inc(x_32);
+if (lean_is_exclusive(x_30)) {
+ lean_ctor_release(x_30, 0);
+ lean_ctor_release(x_30, 1);
+ x_33 = x_30;
 } else {
- lean_dec_ref(x_29);
- x_32 = lean_box(0);
+ lean_dec_ref(x_30);
+ x_33 = lean_box(0);
 }
-if (lean_is_scalar(x_32)) {
- x_33 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_33)) {
+ x_34 = lean_alloc_ctor(0, 2, 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);
-return x_33;
+lean_ctor_set(x_34, 0, x_31);
+lean_ctor_set(x_34, 1, x_32);
+return x_34;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_34 = lean_ctor_get(x_29, 0);
-lean_inc(x_34);
-x_35 = lean_ctor_get(x_29, 1);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+x_35 = lean_ctor_get(x_30, 0);
 lean_inc(x_35);
-if (lean_is_exclusive(x_29)) {
- lean_ctor_release(x_29, 0);
- lean_ctor_release(x_29, 1);
- x_36 = x_29;
+x_36 = lean_ctor_get(x_30, 1);
+lean_inc(x_36);
+if (lean_is_exclusive(x_30)) {
+ lean_ctor_release(x_30, 0);
+ lean_ctor_release(x_30, 1);
+ x_37 = x_30;
 } else {
- lean_dec_ref(x_29);
- x_36 = lean_box(0);
+ lean_dec_ref(x_30);
+ x_37 = lean_box(0);
 }
-if (lean_is_scalar(x_36)) {
- x_37 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_37)) {
+ x_38 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_37 = x_36;
+ x_38 = x_37;
 }
-lean_ctor_set(x_37, 0, x_34);
-lean_ctor_set(x_37, 1, x_35);
-return x_37;
+lean_ctor_set(x_38, 0, x_35);
+lean_ctor_set(x_38, 1, x_36);
+return x_38;
 }
 }
 }
 else
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; lean_object* x_48; uint8_t x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_38 = lean_ctor_get(x_3, 0);
-x_39 = lean_ctor_get(x_3, 1);
-x_40 = lean_ctor_get(x_3, 2);
-x_41 = lean_ctor_get(x_3, 3);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; lean_object* x_50; uint8_t x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_39 = lean_ctor_get(x_3, 0);
+x_40 = lean_ctor_get(x_3, 1);
+x_41 = lean_ctor_get(x_3, 2);
+x_42 = lean_ctor_get(x_3, 3);
+lean_inc(x_42);
 lean_inc(x_41);
 lean_inc(x_40);
 lean_inc(x_39);
-lean_inc(x_38);
 lean_dec(x_3);
-x_42 = lean_ctor_get_uint8(x_38, 3);
-x_43 = lean_ctor_get_uint8(x_38, 4);
-x_44 = lean_ctor_get_uint8(x_38, 5);
-x_45 = lean_ctor_get_uint8(x_38, 6);
-x_46 = lean_ctor_get_uint8(x_38, 7);
-x_47 = lean_ctor_get_uint8(x_38, 8);
-if (lean_is_exclusive(x_38)) {
- x_48 = x_38;
+x_43 = lean_ctor_get_uint8(x_39, 3);
+x_44 = lean_ctor_get_uint8(x_39, 4);
+x_45 = lean_ctor_get_uint8(x_39, 5);
+x_46 = lean_ctor_get_uint8(x_39, 6);
+x_47 = lean_ctor_get_uint8(x_39, 7);
+x_48 = lean_ctor_get_uint8(x_39, 8);
+x_49 = lean_ctor_get_uint8(x_39, 9);
+if (lean_is_exclusive(x_39)) {
+ x_50 = x_39;
 } else {
- lean_dec_ref(x_38);
- x_48 = lean_box(0);
+ lean_dec_ref(x_39);
+ x_50 = lean_box(0);
 }
-x_49 = 1;
-if (lean_is_scalar(x_48)) {
- x_50 = lean_alloc_ctor(0, 0, 9);
+x_51 = 1;
+if (lean_is_scalar(x_50)) {
+ x_52 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_50 = x_48;
+ x_52 = x_50;
 }
-lean_ctor_set_uint8(x_50, 0, x_49);
-lean_ctor_set_uint8(x_50, 1, x_49);
-lean_ctor_set_uint8(x_50, 2, x_49);
-lean_ctor_set_uint8(x_50, 3, x_42);
-lean_ctor_set_uint8(x_50, 4, x_43);
-lean_ctor_set_uint8(x_50, 5, x_44);
-lean_ctor_set_uint8(x_50, 6, x_45);
-lean_ctor_set_uint8(x_50, 7, x_46);
-lean_ctor_set_uint8(x_50, 8, x_47);
-x_51 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_51, 0, x_50);
-lean_ctor_set(x_51, 1, x_39);
-lean_ctor_set(x_51, 2, x_40);
-lean_ctor_set(x_51, 3, x_41);
-x_52 = lean_apply_7(x_2, lean_box(0), x_1, x_51, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_52) == 0)
+lean_ctor_set_uint8(x_52, 0, x_51);
+lean_ctor_set_uint8(x_52, 1, x_51);
+lean_ctor_set_uint8(x_52, 2, x_51);
+lean_ctor_set_uint8(x_52, 3, x_43);
+lean_ctor_set_uint8(x_52, 4, x_44);
+lean_ctor_set_uint8(x_52, 5, x_45);
+lean_ctor_set_uint8(x_52, 6, x_46);
+lean_ctor_set_uint8(x_52, 7, x_47);
+lean_ctor_set_uint8(x_52, 8, x_48);
+lean_ctor_set_uint8(x_52, 9, x_49);
+x_53 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_53, 0, x_52);
+lean_ctor_set(x_53, 1, x_40);
+lean_ctor_set(x_53, 2, x_41);
+lean_ctor_set(x_53, 3, x_42);
+x_54 = lean_apply_7(x_2, lean_box(0), x_1, x_53, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_54) == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_53 = lean_ctor_get(x_52, 0);
-lean_inc(x_53);
-x_54 = lean_ctor_get(x_52, 1);
-lean_inc(x_54);
-if (lean_is_exclusive(x_52)) {
- lean_ctor_release(x_52, 0);
- lean_ctor_release(x_52, 1);
- x_55 = x_52;
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_55 = lean_ctor_get(x_54, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_54, 1);
+lean_inc(x_56);
+if (lean_is_exclusive(x_54)) {
+ lean_ctor_release(x_54, 0);
+ lean_ctor_release(x_54, 1);
+ x_57 = x_54;
 } else {
- lean_dec_ref(x_52);
- x_55 = lean_box(0);
+ lean_dec_ref(x_54);
+ x_57 = lean_box(0);
 }
-if (lean_is_scalar(x_55)) {
- x_56 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_57)) {
+ x_58 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_56 = x_55;
+ x_58 = x_57;
 }
-lean_ctor_set(x_56, 0, x_53);
-lean_ctor_set(x_56, 1, x_54);
-return x_56;
+lean_ctor_set(x_58, 0, x_55);
+lean_ctor_set(x_58, 1, x_56);
+return x_58;
 }
 else
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_57 = lean_ctor_get(x_52, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_52, 1);
-lean_inc(x_58);
-if (lean_is_exclusive(x_52)) {
- lean_ctor_release(x_52, 0);
- lean_ctor_release(x_52, 1);
- x_59 = x_52;
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_59 = lean_ctor_get(x_54, 0);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_54, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_54)) {
+ lean_ctor_release(x_54, 0);
+ lean_ctor_release(x_54, 1);
+ x_61 = x_54;
 } else {
- lean_dec_ref(x_52);
- x_59 = lean_box(0);
+ lean_dec_ref(x_54);
+ x_61 = lean_box(0);
 }
-if (lean_is_scalar(x_59)) {
- x_60 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_61)) {
+ x_62 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_60 = x_59;
+ x_62 = x_61;
 }
-lean_ctor_set(x_60, 0, x_57);
-lean_ctor_set(x_60, 1, x_58);
-return x_60;
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_60);
+return x_62;
 }
 }
 }
@@ -26032,167 +26212,171 @@ return x_19;
 }
 else
 {
-uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; lean_object* x_26; lean_object* x_27; 
+uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; 
 x_20 = lean_ctor_get_uint8(x_8, 4);
 x_21 = lean_ctor_get_uint8(x_8, 5);
 x_22 = lean_ctor_get_uint8(x_8, 6);
 x_23 = lean_ctor_get_uint8(x_8, 7);
 x_24 = lean_ctor_get_uint8(x_8, 8);
+x_25 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_25 = 1;
-x_26 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_26, 0, x_25);
-lean_ctor_set_uint8(x_26, 1, x_25);
-lean_ctor_set_uint8(x_26, 2, x_25);
-lean_ctor_set_uint8(x_26, 3, x_25);
-lean_ctor_set_uint8(x_26, 4, x_20);
-lean_ctor_set_uint8(x_26, 5, x_21);
-lean_ctor_set_uint8(x_26, 6, x_22);
-lean_ctor_set_uint8(x_26, 7, x_23);
-lean_ctor_set_uint8(x_26, 8, x_24);
-lean_ctor_set(x_2, 0, x_26);
-x_27 = lean_apply_5(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_27) == 0)
+x_26 = 1;
+x_27 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_27, 0, x_26);
+lean_ctor_set_uint8(x_27, 1, x_26);
+lean_ctor_set_uint8(x_27, 2, x_26);
+lean_ctor_set_uint8(x_27, 3, x_26);
+lean_ctor_set_uint8(x_27, 4, x_20);
+lean_ctor_set_uint8(x_27, 5, x_21);
+lean_ctor_set_uint8(x_27, 6, x_22);
+lean_ctor_set_uint8(x_27, 7, x_23);
+lean_ctor_set_uint8(x_27, 8, x_24);
+lean_ctor_set_uint8(x_27, 9, x_25);
+lean_ctor_set(x_2, 0, x_27);
+x_28 = lean_apply_5(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_28 = lean_ctor_get(x_27, 0);
-lean_inc(x_28);
-x_29 = lean_ctor_get(x_27, 1);
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_29 = lean_ctor_get(x_28, 0);
 lean_inc(x_29);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- lean_ctor_release(x_27, 1);
- x_30 = x_27;
+x_30 = lean_ctor_get(x_28, 1);
+lean_inc(x_30);
+if (lean_is_exclusive(x_28)) {
+ lean_ctor_release(x_28, 0);
+ lean_ctor_release(x_28, 1);
+ x_31 = x_28;
 } else {
- lean_dec_ref(x_27);
- x_30 = lean_box(0);
+ lean_dec_ref(x_28);
+ x_31 = lean_box(0);
 }
-if (lean_is_scalar(x_30)) {
- x_31 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_31)) {
+ x_32 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_31 = x_30;
+ x_32 = x_31;
 }
-lean_ctor_set(x_31, 0, x_28);
-lean_ctor_set(x_31, 1, x_29);
-return x_31;
+lean_ctor_set(x_32, 0, x_29);
+lean_ctor_set(x_32, 1, x_30);
+return x_32;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_27, 0);
-lean_inc(x_32);
-x_33 = lean_ctor_get(x_27, 1);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_33 = lean_ctor_get(x_28, 0);
 lean_inc(x_33);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- lean_ctor_release(x_27, 1);
- x_34 = x_27;
+x_34 = lean_ctor_get(x_28, 1);
+lean_inc(x_34);
+if (lean_is_exclusive(x_28)) {
+ lean_ctor_release(x_28, 0);
+ lean_ctor_release(x_28, 1);
+ x_35 = x_28;
 } else {
- lean_dec_ref(x_27);
- x_34 = lean_box(0);
+ lean_dec_ref(x_28);
+ x_35 = lean_box(0);
 }
-if (lean_is_scalar(x_34)) {
- x_35 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_35)) {
+ x_36 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_35 = x_34;
+ x_36 = x_35;
 }
-lean_ctor_set(x_35, 0, x_32);
-lean_ctor_set(x_35, 1, x_33);
-return x_35;
+lean_ctor_set(x_36, 0, x_33);
+lean_ctor_set(x_36, 1, x_34);
+return x_36;
 }
 }
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_36 = lean_ctor_get(x_2, 0);
-x_37 = lean_ctor_get(x_2, 1);
-x_38 = lean_ctor_get(x_2, 2);
-x_39 = lean_ctor_get(x_2, 3);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_37 = lean_ctor_get(x_2, 0);
+x_38 = lean_ctor_get(x_2, 1);
+x_39 = lean_ctor_get(x_2, 2);
+x_40 = lean_ctor_get(x_2, 3);
+lean_inc(x_40);
 lean_inc(x_39);
 lean_inc(x_38);
 lean_inc(x_37);
-lean_inc(x_36);
 lean_dec(x_2);
-x_40 = lean_ctor_get_uint8(x_36, 4);
-x_41 = lean_ctor_get_uint8(x_36, 5);
-x_42 = lean_ctor_get_uint8(x_36, 6);
-x_43 = lean_ctor_get_uint8(x_36, 7);
-x_44 = lean_ctor_get_uint8(x_36, 8);
-if (lean_is_exclusive(x_36)) {
- x_45 = x_36;
+x_41 = lean_ctor_get_uint8(x_37, 4);
+x_42 = lean_ctor_get_uint8(x_37, 5);
+x_43 = lean_ctor_get_uint8(x_37, 6);
+x_44 = lean_ctor_get_uint8(x_37, 7);
+x_45 = lean_ctor_get_uint8(x_37, 8);
+x_46 = lean_ctor_get_uint8(x_37, 9);
+if (lean_is_exclusive(x_37)) {
+ x_47 = x_37;
 } else {
- lean_dec_ref(x_36);
- x_45 = lean_box(0);
+ lean_dec_ref(x_37);
+ x_47 = lean_box(0);
 }
-x_46 = 1;
-if (lean_is_scalar(x_45)) {
- x_47 = lean_alloc_ctor(0, 0, 9);
+x_48 = 1;
+if (lean_is_scalar(x_47)) {
+ x_49 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_47 = x_45;
+ x_49 = x_47;
 }
-lean_ctor_set_uint8(x_47, 0, x_46);
-lean_ctor_set_uint8(x_47, 1, x_46);
-lean_ctor_set_uint8(x_47, 2, x_46);
-lean_ctor_set_uint8(x_47, 3, x_46);
-lean_ctor_set_uint8(x_47, 4, x_40);
-lean_ctor_set_uint8(x_47, 5, x_41);
-lean_ctor_set_uint8(x_47, 6, x_42);
-lean_ctor_set_uint8(x_47, 7, x_43);
-lean_ctor_set_uint8(x_47, 8, x_44);
-x_48 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_48, 0, x_47);
-lean_ctor_set(x_48, 1, x_37);
-lean_ctor_set(x_48, 2, x_38);
-lean_ctor_set(x_48, 3, x_39);
-x_49 = lean_apply_5(x_1, x_48, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_49) == 0)
+lean_ctor_set_uint8(x_49, 0, x_48);
+lean_ctor_set_uint8(x_49, 1, x_48);
+lean_ctor_set_uint8(x_49, 2, x_48);
+lean_ctor_set_uint8(x_49, 3, x_48);
+lean_ctor_set_uint8(x_49, 4, x_41);
+lean_ctor_set_uint8(x_49, 5, x_42);
+lean_ctor_set_uint8(x_49, 6, x_43);
+lean_ctor_set_uint8(x_49, 7, x_44);
+lean_ctor_set_uint8(x_49, 8, x_45);
+lean_ctor_set_uint8(x_49, 9, x_46);
+x_50 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_50, 0, x_49);
+lean_ctor_set(x_50, 1, x_38);
+lean_ctor_set(x_50, 2, x_39);
+lean_ctor_set(x_50, 3, x_40);
+x_51 = lean_apply_5(x_1, x_50, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_51) == 0)
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_50 = lean_ctor_get(x_49, 0);
-lean_inc(x_50);
-x_51 = lean_ctor_get(x_49, 1);
-lean_inc(x_51);
-if (lean_is_exclusive(x_49)) {
- lean_ctor_release(x_49, 0);
- lean_ctor_release(x_49, 1);
- x_52 = x_49;
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+x_52 = lean_ctor_get(x_51, 0);
+lean_inc(x_52);
+x_53 = lean_ctor_get(x_51, 1);
+lean_inc(x_53);
+if (lean_is_exclusive(x_51)) {
+ lean_ctor_release(x_51, 0);
+ lean_ctor_release(x_51, 1);
+ x_54 = x_51;
 } else {
- lean_dec_ref(x_49);
- x_52 = lean_box(0);
+ lean_dec_ref(x_51);
+ x_54 = lean_box(0);
 }
-if (lean_is_scalar(x_52)) {
- x_53 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_54)) {
+ x_55 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_53 = x_52;
+ x_55 = x_54;
 }
-lean_ctor_set(x_53, 0, x_50);
-lean_ctor_set(x_53, 1, x_51);
-return x_53;
+lean_ctor_set(x_55, 0, x_52);
+lean_ctor_set(x_55, 1, x_53);
+return x_55;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_54 = lean_ctor_get(x_49, 0);
-lean_inc(x_54);
-x_55 = lean_ctor_get(x_49, 1);
-lean_inc(x_55);
-if (lean_is_exclusive(x_49)) {
- lean_ctor_release(x_49, 0);
- lean_ctor_release(x_49, 1);
- x_56 = x_49;
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_56 = lean_ctor_get(x_51, 0);
+lean_inc(x_56);
+x_57 = lean_ctor_get(x_51, 1);
+lean_inc(x_57);
+if (lean_is_exclusive(x_51)) {
+ lean_ctor_release(x_51, 0);
+ lean_ctor_release(x_51, 1);
+ x_58 = x_51;
 } else {
- lean_dec_ref(x_49);
- x_56 = lean_box(0);
+ lean_dec_ref(x_51);
+ x_58 = lean_box(0);
 }
-if (lean_is_scalar(x_56)) {
- x_57 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_58)) {
+ x_59 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_57 = x_56;
+ x_59 = x_58;
 }
-lean_ctor_set(x_57, 0, x_54);
-lean_ctor_set(x_57, 1, x_55);
-return x_57;
+lean_ctor_set(x_59, 0, x_56);
+lean_ctor_set(x_59, 1, x_57);
+return x_59;
 }
 }
 }
@@ -26271,167 +26455,171 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; 
 x_21 = lean_ctor_get_uint8(x_9, 4);
 x_22 = lean_ctor_get_uint8(x_9, 5);
 x_23 = lean_ctor_get_uint8(x_9, 6);
 x_24 = lean_ctor_get_uint8(x_9, 7);
 x_25 = lean_ctor_get_uint8(x_9, 8);
+x_26 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_26 = 1;
-x_27 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_27, 0, x_26);
-lean_ctor_set_uint8(x_27, 1, x_26);
-lean_ctor_set_uint8(x_27, 2, x_26);
-lean_ctor_set_uint8(x_27, 3, x_26);
-lean_ctor_set_uint8(x_27, 4, x_21);
-lean_ctor_set_uint8(x_27, 5, x_22);
-lean_ctor_set_uint8(x_27, 6, x_23);
-lean_ctor_set_uint8(x_27, 7, x_24);
-lean_ctor_set_uint8(x_27, 8, x_25);
-lean_ctor_set(x_3, 0, x_27);
-x_28 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_28) == 0)
+x_27 = 1;
+x_28 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_28, 0, x_27);
+lean_ctor_set_uint8(x_28, 1, x_27);
+lean_ctor_set_uint8(x_28, 2, x_27);
+lean_ctor_set_uint8(x_28, 3, x_27);
+lean_ctor_set_uint8(x_28, 4, x_21);
+lean_ctor_set_uint8(x_28, 5, x_22);
+lean_ctor_set_uint8(x_28, 6, x_23);
+lean_ctor_set_uint8(x_28, 7, x_24);
+lean_ctor_set_uint8(x_28, 8, x_25);
+lean_ctor_set_uint8(x_28, 9, x_26);
+lean_ctor_set(x_3, 0, x_28);
+x_29 = lean_apply_7(x_2, lean_box(0), x_1, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = lean_ctor_get(x_28, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_28, 1);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
-if (lean_is_exclusive(x_28)) {
- lean_ctor_release(x_28, 0);
- lean_ctor_release(x_28, 1);
- x_31 = x_28;
+x_31 = lean_ctor_get(x_29, 1);
+lean_inc(x_31);
+if (lean_is_exclusive(x_29)) {
+ lean_ctor_release(x_29, 0);
+ lean_ctor_release(x_29, 1);
+ x_32 = x_29;
 } else {
- lean_dec_ref(x_28);
- x_31 = lean_box(0);
+ lean_dec_ref(x_29);
+ x_32 = lean_box(0);
 }
-if (lean_is_scalar(x_31)) {
- x_32 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_32)) {
+ x_33 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_32 = x_31;
+ x_33 = x_32;
 }
-lean_ctor_set(x_32, 0, x_29);
-lean_ctor_set(x_32, 1, x_30);
-return x_32;
+lean_ctor_set(x_33, 0, x_30);
+lean_ctor_set(x_33, 1, x_31);
+return x_33;
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_33 = lean_ctor_get(x_28, 0);
-lean_inc(x_33);
-x_34 = lean_ctor_get(x_28, 1);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_34 = lean_ctor_get(x_29, 0);
 lean_inc(x_34);
-if (lean_is_exclusive(x_28)) {
- lean_ctor_release(x_28, 0);
- lean_ctor_release(x_28, 1);
- x_35 = x_28;
+x_35 = lean_ctor_get(x_29, 1);
+lean_inc(x_35);
+if (lean_is_exclusive(x_29)) {
+ lean_ctor_release(x_29, 0);
+ lean_ctor_release(x_29, 1);
+ x_36 = x_29;
 } else {
- lean_dec_ref(x_28);
- x_35 = lean_box(0);
+ lean_dec_ref(x_29);
+ x_36 = lean_box(0);
 }
-if (lean_is_scalar(x_35)) {
- x_36 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_36)) {
+ x_37 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_36 = x_35;
+ x_37 = x_36;
 }
-lean_ctor_set(x_36, 0, x_33);
-lean_ctor_set(x_36, 1, x_34);
-return x_36;
+lean_ctor_set(x_37, 0, x_34);
+lean_ctor_set(x_37, 1, x_35);
+return x_37;
 }
 }
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; lean_object* x_46; uint8_t x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-x_37 = lean_ctor_get(x_3, 0);
-x_38 = lean_ctor_get(x_3, 1);
-x_39 = lean_ctor_get(x_3, 2);
-x_40 = lean_ctor_get(x_3, 3);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; lean_object* x_48; uint8_t x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+x_38 = lean_ctor_get(x_3, 0);
+x_39 = lean_ctor_get(x_3, 1);
+x_40 = lean_ctor_get(x_3, 2);
+x_41 = lean_ctor_get(x_3, 3);
+lean_inc(x_41);
 lean_inc(x_40);
 lean_inc(x_39);
 lean_inc(x_38);
-lean_inc(x_37);
 lean_dec(x_3);
-x_41 = lean_ctor_get_uint8(x_37, 4);
-x_42 = lean_ctor_get_uint8(x_37, 5);
-x_43 = lean_ctor_get_uint8(x_37, 6);
-x_44 = lean_ctor_get_uint8(x_37, 7);
-x_45 = lean_ctor_get_uint8(x_37, 8);
-if (lean_is_exclusive(x_37)) {
- x_46 = x_37;
+x_42 = lean_ctor_get_uint8(x_38, 4);
+x_43 = lean_ctor_get_uint8(x_38, 5);
+x_44 = lean_ctor_get_uint8(x_38, 6);
+x_45 = lean_ctor_get_uint8(x_38, 7);
+x_46 = lean_ctor_get_uint8(x_38, 8);
+x_47 = lean_ctor_get_uint8(x_38, 9);
+if (lean_is_exclusive(x_38)) {
+ x_48 = x_38;
 } else {
- lean_dec_ref(x_37);
- x_46 = lean_box(0);
+ lean_dec_ref(x_38);
+ x_48 = lean_box(0);
 }
-x_47 = 1;
-if (lean_is_scalar(x_46)) {
- x_48 = lean_alloc_ctor(0, 0, 9);
+x_49 = 1;
+if (lean_is_scalar(x_48)) {
+ x_50 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_48 = x_46;
+ x_50 = x_48;
 }
-lean_ctor_set_uint8(x_48, 0, x_47);
-lean_ctor_set_uint8(x_48, 1, x_47);
-lean_ctor_set_uint8(x_48, 2, x_47);
-lean_ctor_set_uint8(x_48, 3, x_47);
-lean_ctor_set_uint8(x_48, 4, x_41);
-lean_ctor_set_uint8(x_48, 5, x_42);
-lean_ctor_set_uint8(x_48, 6, x_43);
-lean_ctor_set_uint8(x_48, 7, x_44);
-lean_ctor_set_uint8(x_48, 8, x_45);
-x_49 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_38);
-lean_ctor_set(x_49, 2, x_39);
-lean_ctor_set(x_49, 3, x_40);
-x_50 = lean_apply_7(x_2, lean_box(0), x_1, x_49, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_50) == 0)
+lean_ctor_set_uint8(x_50, 0, x_49);
+lean_ctor_set_uint8(x_50, 1, x_49);
+lean_ctor_set_uint8(x_50, 2, x_49);
+lean_ctor_set_uint8(x_50, 3, x_49);
+lean_ctor_set_uint8(x_50, 4, x_42);
+lean_ctor_set_uint8(x_50, 5, x_43);
+lean_ctor_set_uint8(x_50, 6, x_44);
+lean_ctor_set_uint8(x_50, 7, x_45);
+lean_ctor_set_uint8(x_50, 8, x_46);
+lean_ctor_set_uint8(x_50, 9, x_47);
+x_51 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_51, 0, x_50);
+lean_ctor_set(x_51, 1, x_39);
+lean_ctor_set(x_51, 2, x_40);
+lean_ctor_set(x_51, 3, x_41);
+x_52 = lean_apply_7(x_2, lean_box(0), x_1, x_51, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_52) == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-x_51 = lean_ctor_get(x_50, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_50, 1);
-lean_inc(x_52);
-if (lean_is_exclusive(x_50)) {
- lean_ctor_release(x_50, 0);
- lean_ctor_release(x_50, 1);
- x_53 = x_50;
+lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+x_53 = lean_ctor_get(x_52, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_52, 1);
+lean_inc(x_54);
+if (lean_is_exclusive(x_52)) {
+ lean_ctor_release(x_52, 0);
+ lean_ctor_release(x_52, 1);
+ x_55 = x_52;
 } else {
- lean_dec_ref(x_50);
- x_53 = lean_box(0);
+ lean_dec_ref(x_52);
+ x_55 = lean_box(0);
 }
-if (lean_is_scalar(x_53)) {
- x_54 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_55)) {
+ x_56 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_54 = x_53;
+ x_56 = x_55;
 }
-lean_ctor_set(x_54, 0, x_51);
-lean_ctor_set(x_54, 1, x_52);
-return x_54;
+lean_ctor_set(x_56, 0, x_53);
+lean_ctor_set(x_56, 1, x_54);
+return x_56;
 }
 else
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-x_55 = lean_ctor_get(x_50, 0);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_50, 1);
-lean_inc(x_56);
-if (lean_is_exclusive(x_50)) {
- lean_ctor_release(x_50, 0);
- lean_ctor_release(x_50, 1);
- x_57 = x_50;
+lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_57 = lean_ctor_get(x_52, 0);
+lean_inc(x_57);
+x_58 = lean_ctor_get(x_52, 1);
+lean_inc(x_58);
+if (lean_is_exclusive(x_52)) {
+ lean_ctor_release(x_52, 0);
+ lean_ctor_release(x_52, 1);
+ x_59 = x_52;
 } else {
- lean_dec_ref(x_50);
- x_57 = lean_box(0);
+ lean_dec_ref(x_52);
+ x_59 = lean_box(0);
 }
-if (lean_is_scalar(x_57)) {
- x_58 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_59)) {
+ x_60 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_58 = x_57;
+ x_60 = x_59;
 }
-lean_ctor_set(x_58, 0, x_55);
-lean_ctor_set(x_58, 1, x_56);
-return x_58;
+lean_ctor_set(x_60, 0, x_57);
+lean_ctor_set(x_60, 1, x_58);
+return x_60;
 }
 }
 }
@@ -26669,7 +26857,7 @@ return x_19;
 }
 else
 {
-uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
+uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
 x_20 = lean_ctor_get_uint8(x_8, 0);
 x_21 = lean_ctor_get_uint8(x_8, 1);
 x_22 = lean_ctor_get_uint8(x_8, 2);
@@ -26678,164 +26866,168 @@ x_24 = lean_ctor_get_uint8(x_8, 4);
 x_25 = lean_ctor_get_uint8(x_8, 6);
 x_26 = lean_ctor_get_uint8(x_8, 7);
 x_27 = lean_ctor_get_uint8(x_8, 8);
+x_28 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_28 = 2;
-x_29 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_29, 0, x_20);
-lean_ctor_set_uint8(x_29, 1, x_21);
-lean_ctor_set_uint8(x_29, 2, x_22);
-lean_ctor_set_uint8(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, 4, x_24);
-lean_ctor_set_uint8(x_29, 5, x_28);
-lean_ctor_set_uint8(x_29, 6, x_25);
-lean_ctor_set_uint8(x_29, 7, x_26);
-lean_ctor_set_uint8(x_29, 8, x_27);
-lean_ctor_set(x_2, 0, x_29);
-x_30 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_30) == 0)
+x_29 = 2;
+x_30 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_30, 0, x_20);
+lean_ctor_set_uint8(x_30, 1, x_21);
+lean_ctor_set_uint8(x_30, 2, x_22);
+lean_ctor_set_uint8(x_30, 3, x_23);
+lean_ctor_set_uint8(x_30, 4, x_24);
+lean_ctor_set_uint8(x_30, 5, x_29);
+lean_ctor_set_uint8(x_30, 6, x_25);
+lean_ctor_set_uint8(x_30, 7, x_26);
+lean_ctor_set_uint8(x_30, 8, x_27);
+lean_ctor_set_uint8(x_30, 9, x_28);
+lean_ctor_set(x_2, 0, x_30);
+x_31 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_31) == 0)
 {
-lean_object* x_31; lean_object* x_32; lean_object* 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_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_32 = lean_ctor_get(x_31, 0);
 lean_inc(x_32);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_33 = x_30;
+x_33 = lean_ctor_get(x_31, 1);
+lean_inc(x_33);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_34 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_33 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_34 = lean_box(0);
 }
-if (lean_is_scalar(x_33)) {
- x_34 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_34)) {
+ x_35 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_34 = x_33;
+ x_35 = x_34;
 }
-lean_ctor_set(x_34, 0, x_31);
-lean_ctor_set(x_34, 1, x_32);
-return x_34;
+lean_ctor_set(x_35, 0, x_32);
+lean_ctor_set(x_35, 1, x_33);
+return x_35;
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_35 = lean_ctor_get(x_30, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_30, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_36 = lean_ctor_get(x_31, 0);
 lean_inc(x_36);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_37 = x_30;
+x_37 = lean_ctor_get(x_31, 1);
+lean_inc(x_37);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_38 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_37 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_38 = lean_box(0);
 }
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_38)) {
+ x_39 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_38 = x_37;
+ x_39 = x_38;
 }
-lean_ctor_set(x_38, 0, x_35);
-lean_ctor_set(x_38, 1, x_36);
-return x_38;
+lean_ctor_set(x_39, 0, x_36);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_39 = lean_ctor_get(x_2, 0);
-x_40 = lean_ctor_get(x_2, 1);
-x_41 = lean_ctor_get(x_2, 2);
-x_42 = lean_ctor_get(x_2, 3);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_40 = lean_ctor_get(x_2, 0);
+x_41 = lean_ctor_get(x_2, 1);
+x_42 = lean_ctor_get(x_2, 2);
+x_43 = lean_ctor_get(x_2, 3);
+lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
 lean_inc(x_40);
-lean_inc(x_39);
 lean_dec(x_2);
-x_43 = lean_ctor_get_uint8(x_39, 0);
-x_44 = lean_ctor_get_uint8(x_39, 1);
-x_45 = lean_ctor_get_uint8(x_39, 2);
-x_46 = lean_ctor_get_uint8(x_39, 3);
-x_47 = lean_ctor_get_uint8(x_39, 4);
-x_48 = lean_ctor_get_uint8(x_39, 6);
-x_49 = lean_ctor_get_uint8(x_39, 7);
-x_50 = lean_ctor_get_uint8(x_39, 8);
-if (lean_is_exclusive(x_39)) {
- x_51 = x_39;
+x_44 = lean_ctor_get_uint8(x_40, 0);
+x_45 = lean_ctor_get_uint8(x_40, 1);
+x_46 = lean_ctor_get_uint8(x_40, 2);
+x_47 = lean_ctor_get_uint8(x_40, 3);
+x_48 = lean_ctor_get_uint8(x_40, 4);
+x_49 = lean_ctor_get_uint8(x_40, 6);
+x_50 = lean_ctor_get_uint8(x_40, 7);
+x_51 = lean_ctor_get_uint8(x_40, 8);
+x_52 = lean_ctor_get_uint8(x_40, 9);
+if (lean_is_exclusive(x_40)) {
+ x_53 = x_40;
 } else {
- lean_dec_ref(x_39);
- x_51 = lean_box(0);
+ lean_dec_ref(x_40);
+ x_53 = lean_box(0);
 }
-x_52 = 2;
-if (lean_is_scalar(x_51)) {
- x_53 = lean_alloc_ctor(0, 0, 9);
+x_54 = 2;
+if (lean_is_scalar(x_53)) {
+ x_55 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_53 = x_51;
+ x_55 = x_53;
 }
-lean_ctor_set_uint8(x_53, 0, x_43);
-lean_ctor_set_uint8(x_53, 1, x_44);
-lean_ctor_set_uint8(x_53, 2, x_45);
-lean_ctor_set_uint8(x_53, 3, x_46);
-lean_ctor_set_uint8(x_53, 4, x_47);
-lean_ctor_set_uint8(x_53, 5, x_52);
-lean_ctor_set_uint8(x_53, 6, x_48);
-lean_ctor_set_uint8(x_53, 7, x_49);
-lean_ctor_set_uint8(x_53, 8, x_50);
-x_54 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_54, 0, x_53);
-lean_ctor_set(x_54, 1, x_40);
-lean_ctor_set(x_54, 2, x_41);
-lean_ctor_set(x_54, 3, x_42);
-x_55 = l_Lean_Meta_whnf(x_1, x_54, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_55) == 0)
+lean_ctor_set_uint8(x_55, 0, x_44);
+lean_ctor_set_uint8(x_55, 1, x_45);
+lean_ctor_set_uint8(x_55, 2, x_46);
+lean_ctor_set_uint8(x_55, 3, x_47);
+lean_ctor_set_uint8(x_55, 4, x_48);
+lean_ctor_set_uint8(x_55, 5, x_54);
+lean_ctor_set_uint8(x_55, 6, x_49);
+lean_ctor_set_uint8(x_55, 7, x_50);
+lean_ctor_set_uint8(x_55, 8, x_51);
+lean_ctor_set_uint8(x_55, 9, x_52);
+x_56 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_56, 0, x_55);
+lean_ctor_set(x_56, 1, x_41);
+lean_ctor_set(x_56, 2, x_42);
+lean_ctor_set(x_56, 3, x_43);
+x_57 = l_Lean_Meta_whnf(x_1, x_56, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_57) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 1);
-lean_inc(x_57);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_58 = x_55;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_58 = lean_ctor_get(x_57, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_57, 1);
+lean_inc(x_59);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_60 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_58 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_60 = lean_box(0);
 }
-if (lean_is_scalar(x_58)) {
- x_59 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_60)) {
+ x_61 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_59 = x_58;
+ x_61 = x_60;
 }
-lean_ctor_set(x_59, 0, x_56);
-lean_ctor_set(x_59, 1, x_57);
-return x_59;
+lean_ctor_set(x_61, 0, x_58);
+lean_ctor_set(x_61, 1, x_59);
+return x_61;
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_60 = lean_ctor_get(x_55, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_55, 1);
-lean_inc(x_61);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_62 = x_55;
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_62 = lean_ctor_get(x_57, 0);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_57, 1);
+lean_inc(x_63);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_64 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_62 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_64 = lean_box(0);
 }
-if (lean_is_scalar(x_62)) {
- x_63 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_64)) {
+ x_65 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_63 = x_62;
+ x_65 = x_64;
 }
-lean_ctor_set(x_63, 0, x_60);
-lean_ctor_set(x_63, 1, x_61);
-return x_63;
+lean_ctor_set(x_65, 0, x_62);
+lean_ctor_set(x_65, 1, x_63);
+return x_65;
 }
 }
 }
@@ -26903,7 +27095,7 @@ return x_19;
 }
 else
 {
-uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
+uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
 x_20 = lean_ctor_get_uint8(x_8, 0);
 x_21 = lean_ctor_get_uint8(x_8, 1);
 x_22 = lean_ctor_get_uint8(x_8, 2);
@@ -26912,164 +27104,168 @@ x_24 = lean_ctor_get_uint8(x_8, 4);
 x_25 = lean_ctor_get_uint8(x_8, 6);
 x_26 = lean_ctor_get_uint8(x_8, 7);
 x_27 = lean_ctor_get_uint8(x_8, 8);
+x_28 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_28 = 1;
-x_29 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_29, 0, x_20);
-lean_ctor_set_uint8(x_29, 1, x_21);
-lean_ctor_set_uint8(x_29, 2, x_22);
-lean_ctor_set_uint8(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, 4, x_24);
-lean_ctor_set_uint8(x_29, 5, x_28);
-lean_ctor_set_uint8(x_29, 6, x_25);
-lean_ctor_set_uint8(x_29, 7, x_26);
-lean_ctor_set_uint8(x_29, 8, x_27);
-lean_ctor_set(x_2, 0, x_29);
-x_30 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_30) == 0)
+x_29 = 1;
+x_30 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_30, 0, x_20);
+lean_ctor_set_uint8(x_30, 1, x_21);
+lean_ctor_set_uint8(x_30, 2, x_22);
+lean_ctor_set_uint8(x_30, 3, x_23);
+lean_ctor_set_uint8(x_30, 4, x_24);
+lean_ctor_set_uint8(x_30, 5, x_29);
+lean_ctor_set_uint8(x_30, 6, x_25);
+lean_ctor_set_uint8(x_30, 7, x_26);
+lean_ctor_set_uint8(x_30, 8, x_27);
+lean_ctor_set_uint8(x_30, 9, x_28);
+lean_ctor_set(x_2, 0, x_30);
+x_31 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_31) == 0)
 {
-lean_object* x_31; lean_object* x_32; lean_object* 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_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_32 = lean_ctor_get(x_31, 0);
 lean_inc(x_32);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_33 = x_30;
+x_33 = lean_ctor_get(x_31, 1);
+lean_inc(x_33);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_34 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_33 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_34 = lean_box(0);
 }
-if (lean_is_scalar(x_33)) {
- x_34 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_34)) {
+ x_35 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_34 = x_33;
+ x_35 = x_34;
 }
-lean_ctor_set(x_34, 0, x_31);
-lean_ctor_set(x_34, 1, x_32);
-return x_34;
+lean_ctor_set(x_35, 0, x_32);
+lean_ctor_set(x_35, 1, x_33);
+return x_35;
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_35 = lean_ctor_get(x_30, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_30, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_36 = lean_ctor_get(x_31, 0);
 lean_inc(x_36);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_37 = x_30;
+x_37 = lean_ctor_get(x_31, 1);
+lean_inc(x_37);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_38 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_37 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_38 = lean_box(0);
 }
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_38)) {
+ x_39 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_38 = x_37;
+ x_39 = x_38;
 }
-lean_ctor_set(x_38, 0, x_35);
-lean_ctor_set(x_38, 1, x_36);
-return x_38;
+lean_ctor_set(x_39, 0, x_36);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_39 = lean_ctor_get(x_2, 0);
-x_40 = lean_ctor_get(x_2, 1);
-x_41 = lean_ctor_get(x_2, 2);
-x_42 = lean_ctor_get(x_2, 3);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_40 = lean_ctor_get(x_2, 0);
+x_41 = lean_ctor_get(x_2, 1);
+x_42 = lean_ctor_get(x_2, 2);
+x_43 = lean_ctor_get(x_2, 3);
+lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
 lean_inc(x_40);
-lean_inc(x_39);
 lean_dec(x_2);
-x_43 = lean_ctor_get_uint8(x_39, 0);
-x_44 = lean_ctor_get_uint8(x_39, 1);
-x_45 = lean_ctor_get_uint8(x_39, 2);
-x_46 = lean_ctor_get_uint8(x_39, 3);
-x_47 = lean_ctor_get_uint8(x_39, 4);
-x_48 = lean_ctor_get_uint8(x_39, 6);
-x_49 = lean_ctor_get_uint8(x_39, 7);
-x_50 = lean_ctor_get_uint8(x_39, 8);
-if (lean_is_exclusive(x_39)) {
- x_51 = x_39;
+x_44 = lean_ctor_get_uint8(x_40, 0);
+x_45 = lean_ctor_get_uint8(x_40, 1);
+x_46 = lean_ctor_get_uint8(x_40, 2);
+x_47 = lean_ctor_get_uint8(x_40, 3);
+x_48 = lean_ctor_get_uint8(x_40, 4);
+x_49 = lean_ctor_get_uint8(x_40, 6);
+x_50 = lean_ctor_get_uint8(x_40, 7);
+x_51 = lean_ctor_get_uint8(x_40, 8);
+x_52 = lean_ctor_get_uint8(x_40, 9);
+if (lean_is_exclusive(x_40)) {
+ x_53 = x_40;
 } else {
- lean_dec_ref(x_39);
- x_51 = lean_box(0);
+ lean_dec_ref(x_40);
+ x_53 = lean_box(0);
 }
-x_52 = 1;
-if (lean_is_scalar(x_51)) {
- x_53 = lean_alloc_ctor(0, 0, 9);
+x_54 = 1;
+if (lean_is_scalar(x_53)) {
+ x_55 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_53 = x_51;
+ x_55 = x_53;
 }
-lean_ctor_set_uint8(x_53, 0, x_43);
-lean_ctor_set_uint8(x_53, 1, x_44);
-lean_ctor_set_uint8(x_53, 2, x_45);
-lean_ctor_set_uint8(x_53, 3, x_46);
-lean_ctor_set_uint8(x_53, 4, x_47);
-lean_ctor_set_uint8(x_53, 5, x_52);
-lean_ctor_set_uint8(x_53, 6, x_48);
-lean_ctor_set_uint8(x_53, 7, x_49);
-lean_ctor_set_uint8(x_53, 8, x_50);
-x_54 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_54, 0, x_53);
-lean_ctor_set(x_54, 1, x_40);
-lean_ctor_set(x_54, 2, x_41);
-lean_ctor_set(x_54, 3, x_42);
-x_55 = l_Lean_Meta_whnf(x_1, x_54, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_55) == 0)
+lean_ctor_set_uint8(x_55, 0, x_44);
+lean_ctor_set_uint8(x_55, 1, x_45);
+lean_ctor_set_uint8(x_55, 2, x_46);
+lean_ctor_set_uint8(x_55, 3, x_47);
+lean_ctor_set_uint8(x_55, 4, x_48);
+lean_ctor_set_uint8(x_55, 5, x_54);
+lean_ctor_set_uint8(x_55, 6, x_49);
+lean_ctor_set_uint8(x_55, 7, x_50);
+lean_ctor_set_uint8(x_55, 8, x_51);
+lean_ctor_set_uint8(x_55, 9, x_52);
+x_56 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_56, 0, x_55);
+lean_ctor_set(x_56, 1, x_41);
+lean_ctor_set(x_56, 2, x_42);
+lean_ctor_set(x_56, 3, x_43);
+x_57 = l_Lean_Meta_whnf(x_1, x_56, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_57) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 1);
-lean_inc(x_57);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_58 = x_55;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_58 = lean_ctor_get(x_57, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_57, 1);
+lean_inc(x_59);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_60 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_58 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_60 = lean_box(0);
 }
-if (lean_is_scalar(x_58)) {
- x_59 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_60)) {
+ x_61 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_59 = x_58;
+ x_61 = x_60;
 }
-lean_ctor_set(x_59, 0, x_56);
-lean_ctor_set(x_59, 1, x_57);
-return x_59;
+lean_ctor_set(x_61, 0, x_58);
+lean_ctor_set(x_61, 1, x_59);
+return x_61;
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_60 = lean_ctor_get(x_55, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_55, 1);
-lean_inc(x_61);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_62 = x_55;
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_62 = lean_ctor_get(x_57, 0);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_57, 1);
+lean_inc(x_63);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_64 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_62 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_64 = lean_box(0);
 }
-if (lean_is_scalar(x_62)) {
- x_63 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_64)) {
+ x_65 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_63 = x_62;
+ x_65 = x_64;
 }
-lean_ctor_set(x_63, 0, x_60);
-lean_ctor_set(x_63, 1, x_61);
-return x_63;
+lean_ctor_set(x_65, 0, x_62);
+lean_ctor_set(x_65, 1, x_63);
+return x_65;
 }
 }
 }
@@ -27137,7 +27333,7 @@ return x_19;
 }
 else
 {
-uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
+uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
 x_20 = lean_ctor_get_uint8(x_8, 0);
 x_21 = lean_ctor_get_uint8(x_8, 1);
 x_22 = lean_ctor_get_uint8(x_8, 2);
@@ -27146,164 +27342,168 @@ x_24 = lean_ctor_get_uint8(x_8, 4);
 x_25 = lean_ctor_get_uint8(x_8, 6);
 x_26 = lean_ctor_get_uint8(x_8, 7);
 x_27 = lean_ctor_get_uint8(x_8, 8);
+x_28 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_28 = 3;
-x_29 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_29, 0, x_20);
-lean_ctor_set_uint8(x_29, 1, x_21);
-lean_ctor_set_uint8(x_29, 2, x_22);
-lean_ctor_set_uint8(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, 4, x_24);
-lean_ctor_set_uint8(x_29, 5, x_28);
-lean_ctor_set_uint8(x_29, 6, x_25);
-lean_ctor_set_uint8(x_29, 7, x_26);
-lean_ctor_set_uint8(x_29, 8, x_27);
-lean_ctor_set(x_2, 0, x_29);
-x_30 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_30) == 0)
+x_29 = 3;
+x_30 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_30, 0, x_20);
+lean_ctor_set_uint8(x_30, 1, x_21);
+lean_ctor_set_uint8(x_30, 2, x_22);
+lean_ctor_set_uint8(x_30, 3, x_23);
+lean_ctor_set_uint8(x_30, 4, x_24);
+lean_ctor_set_uint8(x_30, 5, x_29);
+lean_ctor_set_uint8(x_30, 6, x_25);
+lean_ctor_set_uint8(x_30, 7, x_26);
+lean_ctor_set_uint8(x_30, 8, x_27);
+lean_ctor_set_uint8(x_30, 9, x_28);
+lean_ctor_set(x_2, 0, x_30);
+x_31 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_31) == 0)
 {
-lean_object* x_31; lean_object* x_32; lean_object* 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_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_32 = lean_ctor_get(x_31, 0);
 lean_inc(x_32);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_33 = x_30;
+x_33 = lean_ctor_get(x_31, 1);
+lean_inc(x_33);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_34 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_33 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_34 = lean_box(0);
 }
-if (lean_is_scalar(x_33)) {
- x_34 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_34)) {
+ x_35 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_34 = x_33;
+ x_35 = x_34;
 }
-lean_ctor_set(x_34, 0, x_31);
-lean_ctor_set(x_34, 1, x_32);
-return x_34;
+lean_ctor_set(x_35, 0, x_32);
+lean_ctor_set(x_35, 1, x_33);
+return x_35;
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_35 = lean_ctor_get(x_30, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_30, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_36 = lean_ctor_get(x_31, 0);
 lean_inc(x_36);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_37 = x_30;
+x_37 = lean_ctor_get(x_31, 1);
+lean_inc(x_37);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_38 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_37 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_38 = lean_box(0);
 }
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_38)) {
+ x_39 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_38 = x_37;
+ x_39 = x_38;
 }
-lean_ctor_set(x_38, 0, x_35);
-lean_ctor_set(x_38, 1, x_36);
-return x_38;
+lean_ctor_set(x_39, 0, x_36);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_39 = lean_ctor_get(x_2, 0);
-x_40 = lean_ctor_get(x_2, 1);
-x_41 = lean_ctor_get(x_2, 2);
-x_42 = lean_ctor_get(x_2, 3);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_40 = lean_ctor_get(x_2, 0);
+x_41 = lean_ctor_get(x_2, 1);
+x_42 = lean_ctor_get(x_2, 2);
+x_43 = lean_ctor_get(x_2, 3);
+lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
 lean_inc(x_40);
-lean_inc(x_39);
 lean_dec(x_2);
-x_43 = lean_ctor_get_uint8(x_39, 0);
-x_44 = lean_ctor_get_uint8(x_39, 1);
-x_45 = lean_ctor_get_uint8(x_39, 2);
-x_46 = lean_ctor_get_uint8(x_39, 3);
-x_47 = lean_ctor_get_uint8(x_39, 4);
-x_48 = lean_ctor_get_uint8(x_39, 6);
-x_49 = lean_ctor_get_uint8(x_39, 7);
-x_50 = lean_ctor_get_uint8(x_39, 8);
-if (lean_is_exclusive(x_39)) {
- x_51 = x_39;
+x_44 = lean_ctor_get_uint8(x_40, 0);
+x_45 = lean_ctor_get_uint8(x_40, 1);
+x_46 = lean_ctor_get_uint8(x_40, 2);
+x_47 = lean_ctor_get_uint8(x_40, 3);
+x_48 = lean_ctor_get_uint8(x_40, 4);
+x_49 = lean_ctor_get_uint8(x_40, 6);
+x_50 = lean_ctor_get_uint8(x_40, 7);
+x_51 = lean_ctor_get_uint8(x_40, 8);
+x_52 = lean_ctor_get_uint8(x_40, 9);
+if (lean_is_exclusive(x_40)) {
+ x_53 = x_40;
 } else {
- lean_dec_ref(x_39);
- x_51 = lean_box(0);
+ lean_dec_ref(x_40);
+ x_53 = lean_box(0);
 }
-x_52 = 3;
-if (lean_is_scalar(x_51)) {
- x_53 = lean_alloc_ctor(0, 0, 9);
+x_54 = 3;
+if (lean_is_scalar(x_53)) {
+ x_55 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_53 = x_51;
+ x_55 = x_53;
 }
-lean_ctor_set_uint8(x_53, 0, x_43);
-lean_ctor_set_uint8(x_53, 1, x_44);
-lean_ctor_set_uint8(x_53, 2, x_45);
-lean_ctor_set_uint8(x_53, 3, x_46);
-lean_ctor_set_uint8(x_53, 4, x_47);
-lean_ctor_set_uint8(x_53, 5, x_52);
-lean_ctor_set_uint8(x_53, 6, x_48);
-lean_ctor_set_uint8(x_53, 7, x_49);
-lean_ctor_set_uint8(x_53, 8, x_50);
-x_54 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_54, 0, x_53);
-lean_ctor_set(x_54, 1, x_40);
-lean_ctor_set(x_54, 2, x_41);
-lean_ctor_set(x_54, 3, x_42);
-x_55 = l_Lean_Meta_whnf(x_1, x_54, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_55) == 0)
+lean_ctor_set_uint8(x_55, 0, x_44);
+lean_ctor_set_uint8(x_55, 1, x_45);
+lean_ctor_set_uint8(x_55, 2, x_46);
+lean_ctor_set_uint8(x_55, 3, x_47);
+lean_ctor_set_uint8(x_55, 4, x_48);
+lean_ctor_set_uint8(x_55, 5, x_54);
+lean_ctor_set_uint8(x_55, 6, x_49);
+lean_ctor_set_uint8(x_55, 7, x_50);
+lean_ctor_set_uint8(x_55, 8, x_51);
+lean_ctor_set_uint8(x_55, 9, x_52);
+x_56 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_56, 0, x_55);
+lean_ctor_set(x_56, 1, x_41);
+lean_ctor_set(x_56, 2, x_42);
+lean_ctor_set(x_56, 3, x_43);
+x_57 = l_Lean_Meta_whnf(x_1, x_56, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_57) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 1);
-lean_inc(x_57);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_58 = x_55;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_58 = lean_ctor_get(x_57, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_57, 1);
+lean_inc(x_59);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_60 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_58 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_60 = lean_box(0);
 }
-if (lean_is_scalar(x_58)) {
- x_59 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_60)) {
+ x_61 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_59 = x_58;
+ x_61 = x_60;
 }
-lean_ctor_set(x_59, 0, x_56);
-lean_ctor_set(x_59, 1, x_57);
-return x_59;
+lean_ctor_set(x_61, 0, x_58);
+lean_ctor_set(x_61, 1, x_59);
+return x_61;
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_60 = lean_ctor_get(x_55, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_55, 1);
-lean_inc(x_61);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_62 = x_55;
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_62 = lean_ctor_get(x_57, 0);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_57, 1);
+lean_inc(x_63);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_64 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_62 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_64 = lean_box(0);
 }
-if (lean_is_scalar(x_62)) {
- x_63 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_64)) {
+ x_65 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_63 = x_62;
+ x_65 = x_64;
 }
-lean_ctor_set(x_63, 0, x_60);
-lean_ctor_set(x_63, 1, x_61);
-return x_63;
+lean_ctor_set(x_65, 0, x_62);
+lean_ctor_set(x_65, 1, x_63);
+return x_65;
 }
 }
 }
@@ -27617,7 +27817,7 @@ x_21 = lean_ctor_get(x_13, 1);
 lean_inc(x_21);
 lean_dec(x_13);
 x_22 = l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateForallAux___closed__2;
-x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_22, x_4, x_5, x_6, x_7, x_21);
+x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_22, x_4, x_5, x_6, x_7, x_21);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -27764,7 +27964,7 @@ x_21 = lean_ctor_get(x_13, 1);
 lean_inc(x_21);
 lean_dec(x_13);
 x_22 = l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateLambdaAux___closed__2;
-x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_22, x_4, x_5, x_6, x_7, x_21);
+x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_22, x_4, x_5, x_6, x_7, x_21);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -28845,6 +29045,7 @@ l_Lean_Meta_Config_transparency___default = _init_l_Lean_Meta_Config_transparenc
 l_Lean_Meta_Config_zetaNonDep___default = _init_l_Lean_Meta_Config_zetaNonDep___default();
 l_Lean_Meta_Config_trackZeta___default = _init_l_Lean_Meta_Config_trackZeta___default();
 l_Lean_Meta_Config_unificationHints___default = _init_l_Lean_Meta_Config_unificationHints___default();
+l_Lean_Meta_Config_proofIrrelevance___default = _init_l_Lean_Meta_Config_proofIrrelevance___default();
 l_Lean_Meta_ParamInfo_implicit___default = _init_l_Lean_Meta_ParamInfo_implicit___default();
 l_Lean_Meta_ParamInfo_instImplicit___default = _init_l_Lean_Meta_ParamInfo_instImplicit___default();
 l_Lean_Meta_ParamInfo_hasFwdDeps___default = _init_l_Lean_Meta_ParamInfo_hasFwdDeps___default();
@@ -28958,53 +29159,53 @@ l_Lean_Meta_instMetaEvalMetaM___rarg___closed__2 = _init_l_Lean_Meta_instMetaEva
 lean_mark_persistent(l_Lean_Meta_instMetaEvalMetaM___rarg___closed__2);
 l_Lean_Meta_throwIsDefEqStuck___rarg___closed__1 = _init_l_Lean_Meta_throwIsDefEqStuck___rarg___closed__1();
 lean_mark_persistent(l_Lean_Meta_throwIsDefEqStuck___rarg___closed__1);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__1);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__2();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____lambda__1___closed__2);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____closed__1);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__1);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__2();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____lambda__1___closed__2);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____closed__1);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Meta_whnfRef = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Meta_whnfRef);
 lean_dec_ref(res);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__1);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__2();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____lambda__1___closed__2);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669____closed__1);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1669_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__1);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__2();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____lambda__1___closed__2);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678____closed__1);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1678_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Meta_inferTypeRef = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Meta_inferTypeRef);
 lean_dec_ref(res);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__1);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__2();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____lambda__1___closed__2);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726____closed__1);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1726_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__1);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__2();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____lambda__1___closed__2);
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735____closed__1);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1735_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Meta_isExprDefEqAuxRef = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Meta_isExprDefEqAuxRef);
 lean_dec_ref(res);
-l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791____closed__1);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1791_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800____closed__1);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1800_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Meta_synthPendingRef = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Meta_synthPendingRef);
diff --git a/stage0/stdlib/Lean/Meta/Check.c b/stage0/stdlib/Lean/Meta/Check.c
index a32d15b806..7c9dc22bad 100644
--- a/stage0/stdlib/Lean/Meta/Check.c
+++ b/stage0/stdlib/Lean/Meta/Check.c
@@ -13,7 +13,6 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* lean_array_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_throwAppTypeMismatch_match__1(lean_object*);
 size_t l_USize_add(size_t, size_t);
@@ -33,6 +32,7 @@ lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Lean_Meta_addPPExplicitToExposeDiff_visit_match__1(lean_object*);
 lean_object* l_Lean_Meta_throwLetTypeMismatchMessage___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Meta_Check_0__Lean_Meta_checkAux_checkLambdaLet___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_getConstInfo___at_Lean_Meta_mkConstWithFreshMVarLevels___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Check_0__Lean_Meta_checkAux_checkForall___closed__1;
@@ -4234,7 +4234,7 @@ static lean_object* _init_l_Lean_Meta_check___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Meta_check___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -4243,46 +4243,46 @@ return x_3;
 lean_object* l_Lean_Meta_check(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_7; lean_object* x_8; lean_object* x_389; lean_object* x_390; lean_object* x_391; uint8_t x_392; 
-x_389 = lean_st_ref_get(x_5, x_6);
-x_390 = lean_ctor_get(x_389, 0);
-lean_inc(x_390);
-x_391 = lean_ctor_get(x_390, 3);
-lean_inc(x_391);
-lean_dec(x_390);
-x_392 = lean_ctor_get_uint8(x_391, sizeof(void*)*1);
-lean_dec(x_391);
-if (x_392 == 0)
+uint8_t x_7; lean_object* x_8; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; 
+x_394 = lean_st_ref_get(x_5, x_6);
+x_395 = lean_ctor_get(x_394, 0);
+lean_inc(x_395);
+x_396 = lean_ctor_get(x_395, 3);
+lean_inc(x_396);
+lean_dec(x_395);
+x_397 = lean_ctor_get_uint8(x_396, sizeof(void*)*1);
+lean_dec(x_396);
+if (x_397 == 0)
 {
-lean_object* x_393; uint8_t x_394; 
-x_393 = lean_ctor_get(x_389, 1);
-lean_inc(x_393);
-lean_dec(x_389);
-x_394 = 0;
-x_7 = x_394;
-x_8 = x_393;
-goto block_388;
+lean_object* x_398; uint8_t x_399; 
+x_398 = lean_ctor_get(x_394, 1);
+lean_inc(x_398);
+lean_dec(x_394);
+x_399 = 0;
+x_7 = x_399;
+x_8 = x_398;
+goto block_393;
 }
 else
 {
-lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; uint8_t x_400; 
-x_395 = lean_ctor_get(x_389, 1);
-lean_inc(x_395);
-lean_dec(x_389);
-x_396 = l_Lean_Meta_check___closed__2;
-x_397 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_396, x_2, x_3, x_4, x_5, x_395);
-x_398 = lean_ctor_get(x_397, 0);
-lean_inc(x_398);
-x_399 = lean_ctor_get(x_397, 1);
-lean_inc(x_399);
-lean_dec(x_397);
-x_400 = lean_unbox(x_398);
-lean_dec(x_398);
-x_7 = x_400;
-x_8 = x_399;
-goto block_388;
+lean_object* x_400; lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; uint8_t x_405; 
+x_400 = lean_ctor_get(x_394, 1);
+lean_inc(x_400);
+lean_dec(x_394);
+x_401 = l_Lean_Meta_check___closed__2;
+x_402 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_401, x_2, x_3, x_4, x_5, x_400);
+x_403 = lean_ctor_get(x_402, 0);
+lean_inc(x_403);
+x_404 = lean_ctor_get(x_402, 1);
+lean_inc(x_404);
+lean_dec(x_402);
+x_405 = lean_unbox(x_403);
+lean_dec(x_403);
+x_7 = x_405;
+x_8 = x_404;
+goto block_393;
 }
-block_388:
+block_393:
 {
 if (x_7 == 0)
 {
@@ -4622,7 +4622,7 @@ return x_95;
 }
 else
 {
-uint8_t x_96; uint8_t x_97; uint8_t x_98; uint8_t x_99; uint8_t x_100; uint8_t x_101; uint8_t x_102; uint8_t x_103; uint8_t x_104; lean_object* x_105; lean_object* x_106; 
+uint8_t x_96; uint8_t x_97; uint8_t x_98; uint8_t x_99; uint8_t x_100; uint8_t x_101; uint8_t x_102; uint8_t x_103; uint8_t x_104; uint8_t x_105; lean_object* x_106; lean_object* x_107; 
 x_96 = lean_ctor_get_uint8(x_23, 0);
 x_97 = lean_ctor_get_uint8(x_23, 1);
 x_98 = lean_ctor_get_uint8(x_23, 2);
@@ -4631,1106 +4631,1116 @@ x_100 = lean_ctor_get_uint8(x_23, 4);
 x_101 = lean_ctor_get_uint8(x_23, 6);
 x_102 = lean_ctor_get_uint8(x_23, 7);
 x_103 = lean_ctor_get_uint8(x_23, 8);
+x_104 = lean_ctor_get_uint8(x_23, 9);
 lean_dec(x_23);
-x_104 = 0;
-x_105 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_105, 0, x_96);
-lean_ctor_set_uint8(x_105, 1, x_97);
-lean_ctor_set_uint8(x_105, 2, x_98);
-lean_ctor_set_uint8(x_105, 3, x_99);
-lean_ctor_set_uint8(x_105, 4, x_100);
-lean_ctor_set_uint8(x_105, 5, x_104);
-lean_ctor_set_uint8(x_105, 6, x_101);
-lean_ctor_set_uint8(x_105, 7, x_102);
-lean_ctor_set_uint8(x_105, 8, x_103);
-lean_ctor_set(x_2, 0, x_105);
+x_105 = 0;
+x_106 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_106, 0, x_96);
+lean_ctor_set_uint8(x_106, 1, x_97);
+lean_ctor_set_uint8(x_106, 2, x_98);
+lean_ctor_set_uint8(x_106, 3, x_99);
+lean_ctor_set_uint8(x_106, 4, x_100);
+lean_ctor_set_uint8(x_106, 5, x_105);
+lean_ctor_set_uint8(x_106, 6, x_101);
+lean_ctor_set_uint8(x_106, 7, x_102);
+lean_ctor_set_uint8(x_106, 8, x_103);
+lean_ctor_set_uint8(x_106, 9, x_104);
+lean_ctor_set(x_2, 0, x_106);
 lean_inc(x_5);
-x_106 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_2, x_3, x_4, x_5, x_24);
-if (lean_obj_tag(x_106) == 0)
+x_107 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_2, x_3, x_4, x_5, x_24);
+if (lean_obj_tag(x_107) == 0)
 {
-lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 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; 
-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; 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; 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; 
+x_108 = lean_ctor_get(x_107, 0);
 lean_inc(x_108);
-lean_dec(x_106);
-x_109 = lean_st_ref_get(x_5, x_108);
-x_110 = lean_ctor_get(x_109, 1);
-lean_inc(x_110);
-lean_dec(x_109);
-x_111 = lean_st_ref_take(x_5, x_110);
-x_112 = lean_ctor_get(x_111, 0);
-lean_inc(x_112);
-x_113 = lean_ctor_get(x_112, 3);
+x_109 = lean_ctor_get(x_107, 1);
+lean_inc(x_109);
+lean_dec(x_107);
+x_110 = lean_st_ref_get(x_5, x_109);
+x_111 = lean_ctor_get(x_110, 1);
+lean_inc(x_111);
+lean_dec(x_110);
+x_112 = lean_st_ref_take(x_5, x_111);
+x_113 = lean_ctor_get(x_112, 0);
 lean_inc(x_113);
-x_114 = lean_ctor_get(x_111, 1);
+x_114 = lean_ctor_get(x_113, 3);
 lean_inc(x_114);
-lean_dec(x_111);
-x_115 = lean_ctor_get(x_112, 0);
+x_115 = lean_ctor_get(x_112, 1);
 lean_inc(x_115);
-x_116 = lean_ctor_get(x_112, 1);
+lean_dec(x_112);
+x_116 = lean_ctor_get(x_113, 0);
 lean_inc(x_116);
-x_117 = lean_ctor_get(x_112, 2);
+x_117 = lean_ctor_get(x_113, 1);
 lean_inc(x_117);
-if (lean_is_exclusive(x_112)) {
- lean_ctor_release(x_112, 0);
- lean_ctor_release(x_112, 1);
- lean_ctor_release(x_112, 2);
- lean_ctor_release(x_112, 3);
- x_118 = x_112;
-} else {
- lean_dec_ref(x_112);
- x_118 = lean_box(0);
-}
-x_119 = lean_ctor_get(x_113, 0);
-lean_inc(x_119);
+x_118 = lean_ctor_get(x_113, 2);
+lean_inc(x_118);
 if (lean_is_exclusive(x_113)) {
  lean_ctor_release(x_113, 0);
- x_120 = x_113;
+ lean_ctor_release(x_113, 1);
+ lean_ctor_release(x_113, 2);
+ lean_ctor_release(x_113, 3);
+ x_119 = x_113;
 } else {
  lean_dec_ref(x_113);
- x_120 = lean_box(0);
+ x_119 = lean_box(0);
 }
-if (lean_is_scalar(x_120)) {
- x_121 = lean_alloc_ctor(0, 1, 1);
+x_120 = lean_ctor_get(x_114, 0);
+lean_inc(x_120);
+if (lean_is_exclusive(x_114)) {
+ lean_ctor_release(x_114, 0);
+ x_121 = x_114;
 } else {
- x_121 = x_120;
+ lean_dec_ref(x_114);
+ x_121 = lean_box(0);
 }
-lean_ctor_set(x_121, 0, x_119);
-lean_ctor_set_uint8(x_121, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_118)) {
- x_122 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_121)) {
+ x_122 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_122 = x_118;
+ x_122 = x_121;
 }
-lean_ctor_set(x_122, 0, x_115);
-lean_ctor_set(x_122, 1, x_116);
-lean_ctor_set(x_122, 2, x_117);
-lean_ctor_set(x_122, 3, x_121);
-x_123 = lean_st_ref_set(x_5, x_122, x_114);
+lean_ctor_set(x_122, 0, x_120);
+lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_13);
+if (lean_is_scalar(x_119)) {
+ x_123 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_123 = x_119;
+}
+lean_ctor_set(x_123, 0, x_116);
+lean_ctor_set(x_123, 1, x_117);
+lean_ctor_set(x_123, 2, x_118);
+lean_ctor_set(x_123, 3, x_122);
+x_124 = lean_st_ref_set(x_5, x_123, x_115);
 lean_dec(x_5);
-x_124 = lean_ctor_get(x_123, 1);
-lean_inc(x_124);
-if (lean_is_exclusive(x_123)) {
- lean_ctor_release(x_123, 0);
- lean_ctor_release(x_123, 1);
- x_125 = x_123;
+x_125 = lean_ctor_get(x_124, 1);
+lean_inc(x_125);
+if (lean_is_exclusive(x_124)) {
+ lean_ctor_release(x_124, 0);
+ lean_ctor_release(x_124, 1);
+ x_126 = x_124;
 } else {
- lean_dec_ref(x_123);
- x_125 = lean_box(0);
+ lean_dec_ref(x_124);
+ x_126 = lean_box(0);
 }
-if (lean_is_scalar(x_125)) {
- x_126 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_126)) {
+ x_127 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_126 = x_125;
+ x_127 = x_126;
 }
-lean_ctor_set(x_126, 0, x_107);
-lean_ctor_set(x_126, 1, x_124);
-return x_126;
+lean_ctor_set(x_127, 0, x_108);
+lean_ctor_set(x_127, 1, x_125);
+return x_127;
 }
 else
 {
-lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; 
-x_127 = lean_ctor_get(x_106, 0);
-lean_inc(x_127);
-x_128 = lean_ctor_get(x_106, 1);
+lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; 
+x_128 = lean_ctor_get(x_107, 0);
 lean_inc(x_128);
-lean_dec(x_106);
-x_129 = lean_st_ref_get(x_5, x_128);
-x_130 = lean_ctor_get(x_129, 1);
-lean_inc(x_130);
-lean_dec(x_129);
-x_131 = lean_st_ref_take(x_5, x_130);
-x_132 = lean_ctor_get(x_131, 0);
-lean_inc(x_132);
-x_133 = lean_ctor_get(x_132, 3);
+x_129 = lean_ctor_get(x_107, 1);
+lean_inc(x_129);
+lean_dec(x_107);
+x_130 = lean_st_ref_get(x_5, x_129);
+x_131 = lean_ctor_get(x_130, 1);
+lean_inc(x_131);
+lean_dec(x_130);
+x_132 = lean_st_ref_take(x_5, x_131);
+x_133 = lean_ctor_get(x_132, 0);
 lean_inc(x_133);
-x_134 = lean_ctor_get(x_131, 1);
+x_134 = lean_ctor_get(x_133, 3);
 lean_inc(x_134);
-lean_dec(x_131);
-x_135 = lean_ctor_get(x_132, 0);
+x_135 = lean_ctor_get(x_132, 1);
 lean_inc(x_135);
-x_136 = lean_ctor_get(x_132, 1);
+lean_dec(x_132);
+x_136 = lean_ctor_get(x_133, 0);
 lean_inc(x_136);
-x_137 = lean_ctor_get(x_132, 2);
+x_137 = lean_ctor_get(x_133, 1);
 lean_inc(x_137);
-if (lean_is_exclusive(x_132)) {
- lean_ctor_release(x_132, 0);
- lean_ctor_release(x_132, 1);
- lean_ctor_release(x_132, 2);
- lean_ctor_release(x_132, 3);
- x_138 = x_132;
-} else {
- lean_dec_ref(x_132);
- x_138 = lean_box(0);
-}
-x_139 = lean_ctor_get(x_133, 0);
-lean_inc(x_139);
+x_138 = lean_ctor_get(x_133, 2);
+lean_inc(x_138);
 if (lean_is_exclusive(x_133)) {
  lean_ctor_release(x_133, 0);
- x_140 = x_133;
+ lean_ctor_release(x_133, 1);
+ lean_ctor_release(x_133, 2);
+ lean_ctor_release(x_133, 3);
+ x_139 = x_133;
 } else {
  lean_dec_ref(x_133);
- x_140 = lean_box(0);
+ x_139 = lean_box(0);
 }
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(0, 1, 1);
+x_140 = lean_ctor_get(x_134, 0);
+lean_inc(x_140);
+if (lean_is_exclusive(x_134)) {
+ lean_ctor_release(x_134, 0);
+ x_141 = x_134;
 } else {
- x_141 = x_140;
+ lean_dec_ref(x_134);
+ x_141 = lean_box(0);
 }
-lean_ctor_set(x_141, 0, x_139);
-lean_ctor_set_uint8(x_141, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_138)) {
- x_142 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_141)) {
+ x_142 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_142 = x_138;
+ x_142 = x_141;
 }
-lean_ctor_set(x_142, 0, x_135);
-lean_ctor_set(x_142, 1, x_136);
-lean_ctor_set(x_142, 2, x_137);
-lean_ctor_set(x_142, 3, x_141);
-x_143 = lean_st_ref_set(x_5, x_142, x_134);
+lean_ctor_set(x_142, 0, x_140);
+lean_ctor_set_uint8(x_142, sizeof(void*)*1, x_13);
+if (lean_is_scalar(x_139)) {
+ x_143 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_143 = x_139;
+}
+lean_ctor_set(x_143, 0, x_136);
+lean_ctor_set(x_143, 1, x_137);
+lean_ctor_set(x_143, 2, x_138);
+lean_ctor_set(x_143, 3, x_142);
+x_144 = lean_st_ref_set(x_5, x_143, x_135);
 lean_dec(x_5);
-x_144 = lean_ctor_get(x_143, 1);
-lean_inc(x_144);
-if (lean_is_exclusive(x_143)) {
- lean_ctor_release(x_143, 0);
- lean_ctor_release(x_143, 1);
- x_145 = x_143;
+x_145 = lean_ctor_get(x_144, 1);
+lean_inc(x_145);
+if (lean_is_exclusive(x_144)) {
+ lean_ctor_release(x_144, 0);
+ lean_ctor_release(x_144, 1);
+ x_146 = x_144;
 } else {
- lean_dec_ref(x_143);
- x_145 = lean_box(0);
+ lean_dec_ref(x_144);
+ x_146 = lean_box(0);
 }
-if (lean_is_scalar(x_145)) {
- x_146 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_146)) {
+ x_147 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_146 = x_145;
- lean_ctor_set_tag(x_146, 1);
+ x_147 = x_146;
+ lean_ctor_set_tag(x_147, 1);
 }
-lean_ctor_set(x_146, 0, x_127);
-lean_ctor_set(x_146, 1, x_144);
-return x_146;
+lean_ctor_set(x_147, 0, x_128);
+lean_ctor_set(x_147, 1, x_145);
+return x_147;
 }
 }
 }
 else
 {
-lean_object* x_147; lean_object* x_148; lean_object* x_149; uint8_t x_150; uint8_t x_151; uint8_t x_152; uint8_t x_153; uint8_t x_154; uint8_t x_155; uint8_t x_156; uint8_t x_157; lean_object* x_158; uint8_t x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
-x_147 = lean_ctor_get(x_2, 1);
-x_148 = lean_ctor_get(x_2, 2);
-x_149 = lean_ctor_get(x_2, 3);
+lean_object* x_148; lean_object* x_149; lean_object* x_150; uint8_t x_151; uint8_t x_152; uint8_t x_153; uint8_t x_154; uint8_t x_155; uint8_t x_156; uint8_t x_157; uint8_t x_158; uint8_t x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; 
+x_148 = lean_ctor_get(x_2, 1);
+x_149 = lean_ctor_get(x_2, 2);
+x_150 = lean_ctor_get(x_2, 3);
+lean_inc(x_150);
 lean_inc(x_149);
 lean_inc(x_148);
-lean_inc(x_147);
 lean_dec(x_2);
-x_150 = lean_ctor_get_uint8(x_23, 0);
-x_151 = lean_ctor_get_uint8(x_23, 1);
-x_152 = lean_ctor_get_uint8(x_23, 2);
-x_153 = lean_ctor_get_uint8(x_23, 3);
-x_154 = lean_ctor_get_uint8(x_23, 4);
-x_155 = lean_ctor_get_uint8(x_23, 6);
-x_156 = lean_ctor_get_uint8(x_23, 7);
-x_157 = lean_ctor_get_uint8(x_23, 8);
+x_151 = lean_ctor_get_uint8(x_23, 0);
+x_152 = lean_ctor_get_uint8(x_23, 1);
+x_153 = lean_ctor_get_uint8(x_23, 2);
+x_154 = lean_ctor_get_uint8(x_23, 3);
+x_155 = lean_ctor_get_uint8(x_23, 4);
+x_156 = lean_ctor_get_uint8(x_23, 6);
+x_157 = lean_ctor_get_uint8(x_23, 7);
+x_158 = lean_ctor_get_uint8(x_23, 8);
+x_159 = lean_ctor_get_uint8(x_23, 9);
 if (lean_is_exclusive(x_23)) {
- x_158 = x_23;
+ x_160 = x_23;
 } else {
  lean_dec_ref(x_23);
- x_158 = lean_box(0);
+ x_160 = lean_box(0);
 }
-x_159 = 0;
-if (lean_is_scalar(x_158)) {
- x_160 = lean_alloc_ctor(0, 0, 9);
+x_161 = 0;
+if (lean_is_scalar(x_160)) {
+ x_162 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_160 = x_158;
+ x_162 = x_160;
 }
-lean_ctor_set_uint8(x_160, 0, x_150);
-lean_ctor_set_uint8(x_160, 1, x_151);
-lean_ctor_set_uint8(x_160, 2, x_152);
-lean_ctor_set_uint8(x_160, 3, x_153);
-lean_ctor_set_uint8(x_160, 4, x_154);
-lean_ctor_set_uint8(x_160, 5, x_159);
-lean_ctor_set_uint8(x_160, 6, x_155);
-lean_ctor_set_uint8(x_160, 7, x_156);
-lean_ctor_set_uint8(x_160, 8, x_157);
-x_161 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_161, 0, x_160);
-lean_ctor_set(x_161, 1, x_147);
-lean_ctor_set(x_161, 2, x_148);
-lean_ctor_set(x_161, 3, x_149);
+lean_ctor_set_uint8(x_162, 0, x_151);
+lean_ctor_set_uint8(x_162, 1, x_152);
+lean_ctor_set_uint8(x_162, 2, x_153);
+lean_ctor_set_uint8(x_162, 3, x_154);
+lean_ctor_set_uint8(x_162, 4, x_155);
+lean_ctor_set_uint8(x_162, 5, x_161);
+lean_ctor_set_uint8(x_162, 6, x_156);
+lean_ctor_set_uint8(x_162, 7, x_157);
+lean_ctor_set_uint8(x_162, 8, x_158);
+lean_ctor_set_uint8(x_162, 9, x_159);
+x_163 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_163, 0, x_162);
+lean_ctor_set(x_163, 1, x_148);
+lean_ctor_set(x_163, 2, x_149);
+lean_ctor_set(x_163, 3, x_150);
 lean_inc(x_5);
-x_162 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_161, x_3, x_4, x_5, x_24);
-if (lean_obj_tag(x_162) == 0)
+x_164 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_163, x_3, x_4, x_5, x_24);
+if (lean_obj_tag(x_164) == 0)
 {
-lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; 
-x_163 = lean_ctor_get(x_162, 0);
-lean_inc(x_163);
-x_164 = lean_ctor_get(x_162, 1);
-lean_inc(x_164);
-lean_dec(x_162);
-x_165 = lean_st_ref_get(x_5, x_164);
-x_166 = lean_ctor_get(x_165, 1);
+lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; 
+x_165 = lean_ctor_get(x_164, 0);
+lean_inc(x_165);
+x_166 = lean_ctor_get(x_164, 1);
 lean_inc(x_166);
-lean_dec(x_165);
-x_167 = lean_st_ref_take(x_5, x_166);
-x_168 = lean_ctor_get(x_167, 0);
+lean_dec(x_164);
+x_167 = lean_st_ref_get(x_5, x_166);
+x_168 = lean_ctor_get(x_167, 1);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_168, 3);
-lean_inc(x_169);
-x_170 = lean_ctor_get(x_167, 1);
-lean_inc(x_170);
 lean_dec(x_167);
-x_171 = lean_ctor_get(x_168, 0);
+x_169 = lean_st_ref_take(x_5, x_168);
+x_170 = lean_ctor_get(x_169, 0);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_170, 3);
 lean_inc(x_171);
-x_172 = lean_ctor_get(x_168, 1);
+x_172 = lean_ctor_get(x_169, 1);
 lean_inc(x_172);
-x_173 = lean_ctor_get(x_168, 2);
+lean_dec(x_169);
+x_173 = lean_ctor_get(x_170, 0);
 lean_inc(x_173);
-if (lean_is_exclusive(x_168)) {
- lean_ctor_release(x_168, 0);
- lean_ctor_release(x_168, 1);
- lean_ctor_release(x_168, 2);
- lean_ctor_release(x_168, 3);
- x_174 = x_168;
-} else {
- lean_dec_ref(x_168);
- x_174 = lean_box(0);
-}
-x_175 = lean_ctor_get(x_169, 0);
+x_174 = lean_ctor_get(x_170, 1);
+lean_inc(x_174);
+x_175 = lean_ctor_get(x_170, 2);
 lean_inc(x_175);
-if (lean_is_exclusive(x_169)) {
- lean_ctor_release(x_169, 0);
- x_176 = x_169;
+if (lean_is_exclusive(x_170)) {
+ lean_ctor_release(x_170, 0);
+ lean_ctor_release(x_170, 1);
+ lean_ctor_release(x_170, 2);
+ lean_ctor_release(x_170, 3);
+ x_176 = x_170;
 } else {
- lean_dec_ref(x_169);
+ lean_dec_ref(x_170);
  x_176 = lean_box(0);
 }
+x_177 = lean_ctor_get(x_171, 0);
+lean_inc(x_177);
+if (lean_is_exclusive(x_171)) {
+ lean_ctor_release(x_171, 0);
+ x_178 = x_171;
+} else {
+ lean_dec_ref(x_171);
+ x_178 = lean_box(0);
+}
+if (lean_is_scalar(x_178)) {
+ x_179 = lean_alloc_ctor(0, 1, 1);
+} else {
+ x_179 = x_178;
+}
+lean_ctor_set(x_179, 0, x_177);
+lean_ctor_set_uint8(x_179, sizeof(void*)*1, x_13);
 if (lean_is_scalar(x_176)) {
- x_177 = lean_alloc_ctor(0, 1, 1);
+ x_180 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_177 = x_176;
+ x_180 = x_176;
 }
-lean_ctor_set(x_177, 0, x_175);
-lean_ctor_set_uint8(x_177, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_174)) {
- x_178 = lean_alloc_ctor(0, 4, 0);
-} else {
- x_178 = x_174;
-}
-lean_ctor_set(x_178, 0, x_171);
-lean_ctor_set(x_178, 1, x_172);
-lean_ctor_set(x_178, 2, x_173);
-lean_ctor_set(x_178, 3, x_177);
-x_179 = lean_st_ref_set(x_5, x_178, x_170);
+lean_ctor_set(x_180, 0, x_173);
+lean_ctor_set(x_180, 1, x_174);
+lean_ctor_set(x_180, 2, x_175);
+lean_ctor_set(x_180, 3, x_179);
+x_181 = lean_st_ref_set(x_5, x_180, x_172);
 lean_dec(x_5);
-x_180 = lean_ctor_get(x_179, 1);
-lean_inc(x_180);
-if (lean_is_exclusive(x_179)) {
- lean_ctor_release(x_179, 0);
- lean_ctor_release(x_179, 1);
- x_181 = x_179;
+x_182 = lean_ctor_get(x_181, 1);
+lean_inc(x_182);
+if (lean_is_exclusive(x_181)) {
+ lean_ctor_release(x_181, 0);
+ lean_ctor_release(x_181, 1);
+ x_183 = x_181;
 } else {
- lean_dec_ref(x_179);
- x_181 = lean_box(0);
+ lean_dec_ref(x_181);
+ x_183 = lean_box(0);
 }
-if (lean_is_scalar(x_181)) {
- x_182 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_183)) {
+ x_184 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_182 = x_181;
+ x_184 = x_183;
 }
-lean_ctor_set(x_182, 0, x_163);
-lean_ctor_set(x_182, 1, x_180);
-return x_182;
+lean_ctor_set(x_184, 0, x_165);
+lean_ctor_set(x_184, 1, x_182);
+return x_184;
 }
 else
 {
-lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; 
-x_183 = lean_ctor_get(x_162, 0);
-lean_inc(x_183);
-x_184 = lean_ctor_get(x_162, 1);
-lean_inc(x_184);
-lean_dec(x_162);
-x_185 = lean_st_ref_get(x_5, x_184);
-x_186 = lean_ctor_get(x_185, 1);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; 
+x_185 = lean_ctor_get(x_164, 0);
+lean_inc(x_185);
+x_186 = lean_ctor_get(x_164, 1);
 lean_inc(x_186);
-lean_dec(x_185);
-x_187 = lean_st_ref_take(x_5, x_186);
-x_188 = lean_ctor_get(x_187, 0);
+lean_dec(x_164);
+x_187 = lean_st_ref_get(x_5, x_186);
+x_188 = lean_ctor_get(x_187, 1);
 lean_inc(x_188);
-x_189 = lean_ctor_get(x_188, 3);
-lean_inc(x_189);
-x_190 = lean_ctor_get(x_187, 1);
-lean_inc(x_190);
 lean_dec(x_187);
-x_191 = lean_ctor_get(x_188, 0);
+x_189 = lean_st_ref_take(x_5, x_188);
+x_190 = lean_ctor_get(x_189, 0);
+lean_inc(x_190);
+x_191 = lean_ctor_get(x_190, 3);
 lean_inc(x_191);
-x_192 = lean_ctor_get(x_188, 1);
+x_192 = lean_ctor_get(x_189, 1);
 lean_inc(x_192);
-x_193 = lean_ctor_get(x_188, 2);
+lean_dec(x_189);
+x_193 = lean_ctor_get(x_190, 0);
 lean_inc(x_193);
-if (lean_is_exclusive(x_188)) {
- lean_ctor_release(x_188, 0);
- lean_ctor_release(x_188, 1);
- lean_ctor_release(x_188, 2);
- lean_ctor_release(x_188, 3);
- x_194 = x_188;
-} else {
- lean_dec_ref(x_188);
- x_194 = lean_box(0);
-}
-x_195 = lean_ctor_get(x_189, 0);
+x_194 = lean_ctor_get(x_190, 1);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_190, 2);
 lean_inc(x_195);
-if (lean_is_exclusive(x_189)) {
- lean_ctor_release(x_189, 0);
- x_196 = x_189;
+if (lean_is_exclusive(x_190)) {
+ lean_ctor_release(x_190, 0);
+ lean_ctor_release(x_190, 1);
+ lean_ctor_release(x_190, 2);
+ lean_ctor_release(x_190, 3);
+ x_196 = x_190;
 } else {
- lean_dec_ref(x_189);
+ lean_dec_ref(x_190);
  x_196 = lean_box(0);
 }
+x_197 = lean_ctor_get(x_191, 0);
+lean_inc(x_197);
+if (lean_is_exclusive(x_191)) {
+ lean_ctor_release(x_191, 0);
+ x_198 = x_191;
+} else {
+ lean_dec_ref(x_191);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(0, 1, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*1, x_13);
 if (lean_is_scalar(x_196)) {
- x_197 = lean_alloc_ctor(0, 1, 1);
+ x_200 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_197 = x_196;
+ x_200 = x_196;
 }
-lean_ctor_set(x_197, 0, x_195);
-lean_ctor_set_uint8(x_197, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_194)) {
- x_198 = lean_alloc_ctor(0, 4, 0);
-} else {
- x_198 = x_194;
-}
-lean_ctor_set(x_198, 0, x_191);
-lean_ctor_set(x_198, 1, x_192);
-lean_ctor_set(x_198, 2, x_193);
-lean_ctor_set(x_198, 3, x_197);
-x_199 = lean_st_ref_set(x_5, x_198, x_190);
+lean_ctor_set(x_200, 0, x_193);
+lean_ctor_set(x_200, 1, x_194);
+lean_ctor_set(x_200, 2, x_195);
+lean_ctor_set(x_200, 3, x_199);
+x_201 = lean_st_ref_set(x_5, x_200, x_192);
 lean_dec(x_5);
-x_200 = lean_ctor_get(x_199, 1);
-lean_inc(x_200);
-if (lean_is_exclusive(x_199)) {
- lean_ctor_release(x_199, 0);
- lean_ctor_release(x_199, 1);
- x_201 = x_199;
+x_202 = lean_ctor_get(x_201, 1);
+lean_inc(x_202);
+if (lean_is_exclusive(x_201)) {
+ lean_ctor_release(x_201, 0);
+ lean_ctor_release(x_201, 1);
+ x_203 = x_201;
 } else {
- lean_dec_ref(x_199);
- x_201 = lean_box(0);
+ lean_dec_ref(x_201);
+ x_203 = lean_box(0);
 }
-if (lean_is_scalar(x_201)) {
- x_202 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_203)) {
+ x_204 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_202 = x_201;
- lean_ctor_set_tag(x_202, 1);
+ x_204 = x_203;
+ lean_ctor_set_tag(x_204, 1);
 }
-lean_ctor_set(x_202, 0, x_183);
-lean_ctor_set(x_202, 1, x_200);
-return x_202;
+lean_ctor_set(x_204, 0, x_185);
+lean_ctor_set(x_204, 1, x_202);
+return x_204;
 }
 }
 }
 else
 {
-lean_object* x_203; uint8_t x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; uint8_t x_213; uint8_t x_214; uint8_t x_215; uint8_t x_216; uint8_t x_217; uint8_t x_218; uint8_t x_219; uint8_t x_220; lean_object* x_221; uint8_t x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; 
-x_203 = lean_ctor_get(x_16, 0);
-lean_inc(x_203);
+lean_object* x_205; uint8_t x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; uint8_t x_215; uint8_t x_216; uint8_t x_217; uint8_t x_218; uint8_t x_219; uint8_t x_220; uint8_t x_221; uint8_t x_222; uint8_t x_223; lean_object* x_224; uint8_t x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; 
+x_205 = lean_ctor_get(x_16, 0);
+lean_inc(x_205);
 lean_dec(x_16);
-x_204 = 0;
-x_205 = lean_alloc_ctor(0, 1, 1);
-lean_ctor_set(x_205, 0, x_203);
-lean_ctor_set_uint8(x_205, sizeof(void*)*1, x_204);
-lean_ctor_set(x_15, 3, x_205);
-x_206 = lean_st_ref_set(x_5, x_15, x_17);
-x_207 = lean_ctor_get(x_2, 0);
-lean_inc(x_207);
-x_208 = lean_ctor_get(x_206, 1);
-lean_inc(x_208);
-lean_dec(x_206);
-x_209 = lean_ctor_get(x_2, 1);
+x_206 = 0;
+x_207 = lean_alloc_ctor(0, 1, 1);
+lean_ctor_set(x_207, 0, x_205);
+lean_ctor_set_uint8(x_207, sizeof(void*)*1, x_206);
+lean_ctor_set(x_15, 3, x_207);
+x_208 = lean_st_ref_set(x_5, x_15, x_17);
+x_209 = lean_ctor_get(x_2, 0);
 lean_inc(x_209);
-x_210 = lean_ctor_get(x_2, 2);
+x_210 = lean_ctor_get(x_208, 1);
 lean_inc(x_210);
-x_211 = lean_ctor_get(x_2, 3);
+lean_dec(x_208);
+x_211 = lean_ctor_get(x_2, 1);
 lean_inc(x_211);
+x_212 = lean_ctor_get(x_2, 2);
+lean_inc(x_212);
+x_213 = lean_ctor_get(x_2, 3);
+lean_inc(x_213);
 if (lean_is_exclusive(x_2)) {
  lean_ctor_release(x_2, 0);
  lean_ctor_release(x_2, 1);
  lean_ctor_release(x_2, 2);
  lean_ctor_release(x_2, 3);
- x_212 = x_2;
+ x_214 = x_2;
 } else {
  lean_dec_ref(x_2);
- x_212 = lean_box(0);
+ x_214 = lean_box(0);
 }
-x_213 = lean_ctor_get_uint8(x_207, 0);
-x_214 = lean_ctor_get_uint8(x_207, 1);
-x_215 = lean_ctor_get_uint8(x_207, 2);
-x_216 = lean_ctor_get_uint8(x_207, 3);
-x_217 = lean_ctor_get_uint8(x_207, 4);
-x_218 = lean_ctor_get_uint8(x_207, 6);
-x_219 = lean_ctor_get_uint8(x_207, 7);
-x_220 = lean_ctor_get_uint8(x_207, 8);
-if (lean_is_exclusive(x_207)) {
- x_221 = x_207;
+x_215 = lean_ctor_get_uint8(x_209, 0);
+x_216 = lean_ctor_get_uint8(x_209, 1);
+x_217 = lean_ctor_get_uint8(x_209, 2);
+x_218 = lean_ctor_get_uint8(x_209, 3);
+x_219 = lean_ctor_get_uint8(x_209, 4);
+x_220 = lean_ctor_get_uint8(x_209, 6);
+x_221 = lean_ctor_get_uint8(x_209, 7);
+x_222 = lean_ctor_get_uint8(x_209, 8);
+x_223 = lean_ctor_get_uint8(x_209, 9);
+if (lean_is_exclusive(x_209)) {
+ x_224 = x_209;
 } else {
- lean_dec_ref(x_207);
- x_221 = lean_box(0);
+ lean_dec_ref(x_209);
+ x_224 = lean_box(0);
 }
-x_222 = 0;
-if (lean_is_scalar(x_221)) {
- x_223 = lean_alloc_ctor(0, 0, 9);
+x_225 = 0;
+if (lean_is_scalar(x_224)) {
+ x_226 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_223 = x_221;
+ x_226 = x_224;
 }
-lean_ctor_set_uint8(x_223, 0, x_213);
-lean_ctor_set_uint8(x_223, 1, x_214);
-lean_ctor_set_uint8(x_223, 2, x_215);
-lean_ctor_set_uint8(x_223, 3, x_216);
-lean_ctor_set_uint8(x_223, 4, x_217);
-lean_ctor_set_uint8(x_223, 5, x_222);
-lean_ctor_set_uint8(x_223, 6, x_218);
-lean_ctor_set_uint8(x_223, 7, x_219);
-lean_ctor_set_uint8(x_223, 8, x_220);
-if (lean_is_scalar(x_212)) {
- x_224 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set_uint8(x_226, 0, x_215);
+lean_ctor_set_uint8(x_226, 1, x_216);
+lean_ctor_set_uint8(x_226, 2, x_217);
+lean_ctor_set_uint8(x_226, 3, x_218);
+lean_ctor_set_uint8(x_226, 4, x_219);
+lean_ctor_set_uint8(x_226, 5, x_225);
+lean_ctor_set_uint8(x_226, 6, x_220);
+lean_ctor_set_uint8(x_226, 7, x_221);
+lean_ctor_set_uint8(x_226, 8, x_222);
+lean_ctor_set_uint8(x_226, 9, x_223);
+if (lean_is_scalar(x_214)) {
+ x_227 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_224 = x_212;
+ x_227 = x_214;
 }
-lean_ctor_set(x_224, 0, x_223);
-lean_ctor_set(x_224, 1, x_209);
-lean_ctor_set(x_224, 2, x_210);
-lean_ctor_set(x_224, 3, x_211);
+lean_ctor_set(x_227, 0, x_226);
+lean_ctor_set(x_227, 1, x_211);
+lean_ctor_set(x_227, 2, x_212);
+lean_ctor_set(x_227, 3, x_213);
 lean_inc(x_5);
-x_225 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_224, x_3, x_4, x_5, x_208);
-if (lean_obj_tag(x_225) == 0)
+x_228 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_227, x_3, x_4, x_5, x_210);
+if (lean_obj_tag(x_228) == 0)
 {
-lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; 
-x_226 = lean_ctor_get(x_225, 0);
-lean_inc(x_226);
-x_227 = lean_ctor_get(x_225, 1);
-lean_inc(x_227);
-lean_dec(x_225);
-x_228 = lean_st_ref_get(x_5, x_227);
-x_229 = lean_ctor_get(x_228, 1);
+lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; 
+x_229 = lean_ctor_get(x_228, 0);
 lean_inc(x_229);
+x_230 = lean_ctor_get(x_228, 1);
+lean_inc(x_230);
 lean_dec(x_228);
-x_230 = lean_st_ref_take(x_5, x_229);
-x_231 = lean_ctor_get(x_230, 0);
-lean_inc(x_231);
-x_232 = lean_ctor_get(x_231, 3);
+x_231 = lean_st_ref_get(x_5, x_230);
+x_232 = lean_ctor_get(x_231, 1);
 lean_inc(x_232);
-x_233 = lean_ctor_get(x_230, 1);
-lean_inc(x_233);
-lean_dec(x_230);
-x_234 = lean_ctor_get(x_231, 0);
+lean_dec(x_231);
+x_233 = lean_st_ref_take(x_5, x_232);
+x_234 = lean_ctor_get(x_233, 0);
 lean_inc(x_234);
-x_235 = lean_ctor_get(x_231, 1);
+x_235 = lean_ctor_get(x_234, 3);
 lean_inc(x_235);
-x_236 = lean_ctor_get(x_231, 2);
+x_236 = lean_ctor_get(x_233, 1);
 lean_inc(x_236);
-if (lean_is_exclusive(x_231)) {
- lean_ctor_release(x_231, 0);
- lean_ctor_release(x_231, 1);
- lean_ctor_release(x_231, 2);
- lean_ctor_release(x_231, 3);
- x_237 = x_231;
-} else {
- lean_dec_ref(x_231);
- x_237 = lean_box(0);
-}
-x_238 = lean_ctor_get(x_232, 0);
+lean_dec(x_233);
+x_237 = lean_ctor_get(x_234, 0);
+lean_inc(x_237);
+x_238 = lean_ctor_get(x_234, 1);
 lean_inc(x_238);
-if (lean_is_exclusive(x_232)) {
- lean_ctor_release(x_232, 0);
- x_239 = x_232;
+x_239 = lean_ctor_get(x_234, 2);
+lean_inc(x_239);
+if (lean_is_exclusive(x_234)) {
+ lean_ctor_release(x_234, 0);
+ lean_ctor_release(x_234, 1);
+ lean_ctor_release(x_234, 2);
+ lean_ctor_release(x_234, 3);
+ x_240 = x_234;
 } else {
- lean_dec_ref(x_232);
- x_239 = lean_box(0);
+ lean_dec_ref(x_234);
+ x_240 = lean_box(0);
 }
-if (lean_is_scalar(x_239)) {
- x_240 = lean_alloc_ctor(0, 1, 1);
+x_241 = lean_ctor_get(x_235, 0);
+lean_inc(x_241);
+if (lean_is_exclusive(x_235)) {
+ lean_ctor_release(x_235, 0);
+ x_242 = x_235;
 } else {
- x_240 = x_239;
+ lean_dec_ref(x_235);
+ x_242 = lean_box(0);
 }
-lean_ctor_set(x_240, 0, x_238);
-lean_ctor_set_uint8(x_240, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_237)) {
- x_241 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_242)) {
+ x_243 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_241 = x_237;
+ x_243 = x_242;
 }
-lean_ctor_set(x_241, 0, x_234);
-lean_ctor_set(x_241, 1, x_235);
-lean_ctor_set(x_241, 2, x_236);
-lean_ctor_set(x_241, 3, x_240);
-x_242 = lean_st_ref_set(x_5, x_241, x_233);
+lean_ctor_set(x_243, 0, x_241);
+lean_ctor_set_uint8(x_243, sizeof(void*)*1, x_13);
+if (lean_is_scalar(x_240)) {
+ x_244 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_244 = x_240;
+}
+lean_ctor_set(x_244, 0, x_237);
+lean_ctor_set(x_244, 1, x_238);
+lean_ctor_set(x_244, 2, x_239);
+lean_ctor_set(x_244, 3, x_243);
+x_245 = lean_st_ref_set(x_5, x_244, x_236);
 lean_dec(x_5);
-x_243 = lean_ctor_get(x_242, 1);
-lean_inc(x_243);
-if (lean_is_exclusive(x_242)) {
- lean_ctor_release(x_242, 0);
- lean_ctor_release(x_242, 1);
- x_244 = x_242;
-} else {
- lean_dec_ref(x_242);
- x_244 = lean_box(0);
-}
-if (lean_is_scalar(x_244)) {
- x_245 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_245 = x_244;
-}
-lean_ctor_set(x_245, 0, x_226);
-lean_ctor_set(x_245, 1, x_243);
-return x_245;
-}
-else
-{
-lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; 
-x_246 = lean_ctor_get(x_225, 0);
+x_246 = lean_ctor_get(x_245, 1);
 lean_inc(x_246);
-x_247 = lean_ctor_get(x_225, 1);
-lean_inc(x_247);
-lean_dec(x_225);
-x_248 = lean_st_ref_get(x_5, x_247);
-x_249 = lean_ctor_get(x_248, 1);
+if (lean_is_exclusive(x_245)) {
+ lean_ctor_release(x_245, 0);
+ lean_ctor_release(x_245, 1);
+ x_247 = x_245;
+} else {
+ lean_dec_ref(x_245);
+ x_247 = lean_box(0);
+}
+if (lean_is_scalar(x_247)) {
+ x_248 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_248 = x_247;
+}
+lean_ctor_set(x_248, 0, x_229);
+lean_ctor_set(x_248, 1, x_246);
+return x_248;
+}
+else
+{
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; 
+x_249 = lean_ctor_get(x_228, 0);
 lean_inc(x_249);
-lean_dec(x_248);
-x_250 = lean_st_ref_take(x_5, x_249);
-x_251 = lean_ctor_get(x_250, 0);
-lean_inc(x_251);
-x_252 = lean_ctor_get(x_251, 3);
+x_250 = lean_ctor_get(x_228, 1);
+lean_inc(x_250);
+lean_dec(x_228);
+x_251 = lean_st_ref_get(x_5, x_250);
+x_252 = lean_ctor_get(x_251, 1);
 lean_inc(x_252);
-x_253 = lean_ctor_get(x_250, 1);
-lean_inc(x_253);
-lean_dec(x_250);
-x_254 = lean_ctor_get(x_251, 0);
+lean_dec(x_251);
+x_253 = lean_st_ref_take(x_5, x_252);
+x_254 = lean_ctor_get(x_253, 0);
 lean_inc(x_254);
-x_255 = lean_ctor_get(x_251, 1);
+x_255 = lean_ctor_get(x_254, 3);
 lean_inc(x_255);
-x_256 = lean_ctor_get(x_251, 2);
+x_256 = lean_ctor_get(x_253, 1);
 lean_inc(x_256);
-if (lean_is_exclusive(x_251)) {
- lean_ctor_release(x_251, 0);
- lean_ctor_release(x_251, 1);
- lean_ctor_release(x_251, 2);
- lean_ctor_release(x_251, 3);
- x_257 = x_251;
-} else {
- lean_dec_ref(x_251);
- x_257 = lean_box(0);
-}
-x_258 = lean_ctor_get(x_252, 0);
+lean_dec(x_253);
+x_257 = lean_ctor_get(x_254, 0);
+lean_inc(x_257);
+x_258 = lean_ctor_get(x_254, 1);
 lean_inc(x_258);
-if (lean_is_exclusive(x_252)) {
- lean_ctor_release(x_252, 0);
- x_259 = x_252;
+x_259 = lean_ctor_get(x_254, 2);
+lean_inc(x_259);
+if (lean_is_exclusive(x_254)) {
+ lean_ctor_release(x_254, 0);
+ lean_ctor_release(x_254, 1);
+ lean_ctor_release(x_254, 2);
+ lean_ctor_release(x_254, 3);
+ x_260 = x_254;
 } else {
- lean_dec_ref(x_252);
- x_259 = lean_box(0);
+ lean_dec_ref(x_254);
+ x_260 = lean_box(0);
 }
-if (lean_is_scalar(x_259)) {
- x_260 = lean_alloc_ctor(0, 1, 1);
+x_261 = lean_ctor_get(x_255, 0);
+lean_inc(x_261);
+if (lean_is_exclusive(x_255)) {
+ lean_ctor_release(x_255, 0);
+ x_262 = x_255;
 } else {
- x_260 = x_259;
+ lean_dec_ref(x_255);
+ x_262 = lean_box(0);
 }
-lean_ctor_set(x_260, 0, x_258);
-lean_ctor_set_uint8(x_260, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_257)) {
- x_261 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_262)) {
+ x_263 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_261 = x_257;
+ x_263 = x_262;
 }
-lean_ctor_set(x_261, 0, x_254);
-lean_ctor_set(x_261, 1, x_255);
-lean_ctor_set(x_261, 2, x_256);
-lean_ctor_set(x_261, 3, x_260);
-x_262 = lean_st_ref_set(x_5, x_261, x_253);
+lean_ctor_set(x_263, 0, x_261);
+lean_ctor_set_uint8(x_263, sizeof(void*)*1, x_13);
+if (lean_is_scalar(x_260)) {
+ x_264 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_264 = x_260;
+}
+lean_ctor_set(x_264, 0, x_257);
+lean_ctor_set(x_264, 1, x_258);
+lean_ctor_set(x_264, 2, x_259);
+lean_ctor_set(x_264, 3, x_263);
+x_265 = lean_st_ref_set(x_5, x_264, x_256);
 lean_dec(x_5);
-x_263 = lean_ctor_get(x_262, 1);
-lean_inc(x_263);
-if (lean_is_exclusive(x_262)) {
- lean_ctor_release(x_262, 0);
- lean_ctor_release(x_262, 1);
- x_264 = x_262;
+x_266 = lean_ctor_get(x_265, 1);
+lean_inc(x_266);
+if (lean_is_exclusive(x_265)) {
+ lean_ctor_release(x_265, 0);
+ lean_ctor_release(x_265, 1);
+ x_267 = x_265;
 } else {
- lean_dec_ref(x_262);
- x_264 = lean_box(0);
+ lean_dec_ref(x_265);
+ x_267 = lean_box(0);
 }
-if (lean_is_scalar(x_264)) {
- x_265 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_267)) {
+ x_268 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_265 = x_264;
- lean_ctor_set_tag(x_265, 1);
+ x_268 = x_267;
+ lean_ctor_set_tag(x_268, 1);
 }
-lean_ctor_set(x_265, 0, x_246);
-lean_ctor_set(x_265, 1, x_263);
-return x_265;
+lean_ctor_set(x_268, 0, x_249);
+lean_ctor_set(x_268, 1, x_266);
+return x_268;
 }
 }
 }
 else
 {
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; uint8_t x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; uint8_t x_281; uint8_t x_282; uint8_t x_283; uint8_t x_284; uint8_t x_285; uint8_t x_286; uint8_t x_287; uint8_t x_288; lean_object* x_289; uint8_t x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_266 = lean_ctor_get(x_15, 0);
-x_267 = lean_ctor_get(x_15, 1);
-x_268 = lean_ctor_get(x_15, 2);
-lean_inc(x_268);
-lean_inc(x_267);
-lean_inc(x_266);
-lean_dec(x_15);
-x_269 = lean_ctor_get(x_16, 0);
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; uint8_t x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; uint8_t x_285; uint8_t x_286; uint8_t x_287; uint8_t x_288; uint8_t x_289; uint8_t x_290; uint8_t x_291; uint8_t x_292; lean_object* x_293; uint8_t x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; 
+x_269 = lean_ctor_get(x_15, 0);
+x_270 = lean_ctor_get(x_15, 1);
+x_271 = lean_ctor_get(x_15, 2);
+lean_inc(x_271);
+lean_inc(x_270);
 lean_inc(x_269);
+lean_dec(x_15);
+x_272 = lean_ctor_get(x_16, 0);
+lean_inc(x_272);
 if (lean_is_exclusive(x_16)) {
  lean_ctor_release(x_16, 0);
- x_270 = x_16;
+ x_273 = x_16;
 } else {
  lean_dec_ref(x_16);
- x_270 = lean_box(0);
+ x_273 = lean_box(0);
 }
-x_271 = 0;
-if (lean_is_scalar(x_270)) {
- x_272 = lean_alloc_ctor(0, 1, 1);
+x_274 = 0;
+if (lean_is_scalar(x_273)) {
+ x_275 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_272 = x_270;
+ x_275 = x_273;
 }
-lean_ctor_set(x_272, 0, x_269);
-lean_ctor_set_uint8(x_272, sizeof(void*)*1, x_271);
-x_273 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_273, 0, x_266);
-lean_ctor_set(x_273, 1, x_267);
-lean_ctor_set(x_273, 2, x_268);
-lean_ctor_set(x_273, 3, x_272);
-x_274 = lean_st_ref_set(x_5, x_273, x_17);
-x_275 = lean_ctor_get(x_2, 0);
-lean_inc(x_275);
-x_276 = lean_ctor_get(x_274, 1);
-lean_inc(x_276);
-lean_dec(x_274);
-x_277 = lean_ctor_get(x_2, 1);
-lean_inc(x_277);
-x_278 = lean_ctor_get(x_2, 2);
+lean_ctor_set(x_275, 0, x_272);
+lean_ctor_set_uint8(x_275, sizeof(void*)*1, x_274);
+x_276 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_276, 0, x_269);
+lean_ctor_set(x_276, 1, x_270);
+lean_ctor_set(x_276, 2, x_271);
+lean_ctor_set(x_276, 3, x_275);
+x_277 = lean_st_ref_set(x_5, x_276, x_17);
+x_278 = lean_ctor_get(x_2, 0);
 lean_inc(x_278);
-x_279 = lean_ctor_get(x_2, 3);
+x_279 = lean_ctor_get(x_277, 1);
 lean_inc(x_279);
+lean_dec(x_277);
+x_280 = lean_ctor_get(x_2, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_2, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_2, 3);
+lean_inc(x_282);
 if (lean_is_exclusive(x_2)) {
  lean_ctor_release(x_2, 0);
  lean_ctor_release(x_2, 1);
  lean_ctor_release(x_2, 2);
  lean_ctor_release(x_2, 3);
- x_280 = x_2;
+ x_283 = x_2;
 } else {
  lean_dec_ref(x_2);
- x_280 = lean_box(0);
+ x_283 = lean_box(0);
 }
-x_281 = lean_ctor_get_uint8(x_275, 0);
-x_282 = lean_ctor_get_uint8(x_275, 1);
-x_283 = lean_ctor_get_uint8(x_275, 2);
-x_284 = lean_ctor_get_uint8(x_275, 3);
-x_285 = lean_ctor_get_uint8(x_275, 4);
-x_286 = lean_ctor_get_uint8(x_275, 6);
-x_287 = lean_ctor_get_uint8(x_275, 7);
-x_288 = lean_ctor_get_uint8(x_275, 8);
-if (lean_is_exclusive(x_275)) {
- x_289 = x_275;
+x_284 = lean_ctor_get_uint8(x_278, 0);
+x_285 = lean_ctor_get_uint8(x_278, 1);
+x_286 = lean_ctor_get_uint8(x_278, 2);
+x_287 = lean_ctor_get_uint8(x_278, 3);
+x_288 = lean_ctor_get_uint8(x_278, 4);
+x_289 = lean_ctor_get_uint8(x_278, 6);
+x_290 = lean_ctor_get_uint8(x_278, 7);
+x_291 = lean_ctor_get_uint8(x_278, 8);
+x_292 = lean_ctor_get_uint8(x_278, 9);
+if (lean_is_exclusive(x_278)) {
+ x_293 = x_278;
 } else {
- lean_dec_ref(x_275);
- x_289 = lean_box(0);
+ lean_dec_ref(x_278);
+ x_293 = lean_box(0);
 }
-x_290 = 0;
-if (lean_is_scalar(x_289)) {
- x_291 = lean_alloc_ctor(0, 0, 9);
+x_294 = 0;
+if (lean_is_scalar(x_293)) {
+ x_295 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_291 = x_289;
+ x_295 = x_293;
 }
-lean_ctor_set_uint8(x_291, 0, x_281);
-lean_ctor_set_uint8(x_291, 1, x_282);
-lean_ctor_set_uint8(x_291, 2, x_283);
-lean_ctor_set_uint8(x_291, 3, x_284);
-lean_ctor_set_uint8(x_291, 4, x_285);
-lean_ctor_set_uint8(x_291, 5, x_290);
-lean_ctor_set_uint8(x_291, 6, x_286);
-lean_ctor_set_uint8(x_291, 7, x_287);
-lean_ctor_set_uint8(x_291, 8, x_288);
-if (lean_is_scalar(x_280)) {
- x_292 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set_uint8(x_295, 0, x_284);
+lean_ctor_set_uint8(x_295, 1, x_285);
+lean_ctor_set_uint8(x_295, 2, x_286);
+lean_ctor_set_uint8(x_295, 3, x_287);
+lean_ctor_set_uint8(x_295, 4, x_288);
+lean_ctor_set_uint8(x_295, 5, x_294);
+lean_ctor_set_uint8(x_295, 6, x_289);
+lean_ctor_set_uint8(x_295, 7, x_290);
+lean_ctor_set_uint8(x_295, 8, x_291);
+lean_ctor_set_uint8(x_295, 9, x_292);
+if (lean_is_scalar(x_283)) {
+ x_296 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_292 = x_280;
+ x_296 = x_283;
 }
-lean_ctor_set(x_292, 0, x_291);
-lean_ctor_set(x_292, 1, x_277);
-lean_ctor_set(x_292, 2, x_278);
-lean_ctor_set(x_292, 3, x_279);
+lean_ctor_set(x_296, 0, x_295);
+lean_ctor_set(x_296, 1, x_280);
+lean_ctor_set(x_296, 2, x_281);
+lean_ctor_set(x_296, 3, x_282);
 lean_inc(x_5);
-x_293 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_292, x_3, x_4, x_5, x_276);
-if (lean_obj_tag(x_293) == 0)
+x_297 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_296, x_3, x_4, x_5, x_279);
+if (lean_obj_tag(x_297) == 0)
 {
-lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; 
-x_294 = lean_ctor_get(x_293, 0);
-lean_inc(x_294);
-x_295 = lean_ctor_get(x_293, 1);
-lean_inc(x_295);
-lean_dec(x_293);
-x_296 = lean_st_ref_get(x_5, x_295);
-x_297 = lean_ctor_get(x_296, 1);
-lean_inc(x_297);
-lean_dec(x_296);
-x_298 = lean_st_ref_take(x_5, x_297);
-x_299 = lean_ctor_get(x_298, 0);
+lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; 
+x_298 = lean_ctor_get(x_297, 0);
+lean_inc(x_298);
+x_299 = lean_ctor_get(x_297, 1);
 lean_inc(x_299);
-x_300 = lean_ctor_get(x_299, 3);
-lean_inc(x_300);
-x_301 = lean_ctor_get(x_298, 1);
+lean_dec(x_297);
+x_300 = lean_st_ref_get(x_5, x_299);
+x_301 = lean_ctor_get(x_300, 1);
 lean_inc(x_301);
-lean_dec(x_298);
-x_302 = lean_ctor_get(x_299, 0);
-lean_inc(x_302);
-x_303 = lean_ctor_get(x_299, 1);
+lean_dec(x_300);
+x_302 = lean_st_ref_take(x_5, x_301);
+x_303 = lean_ctor_get(x_302, 0);
 lean_inc(x_303);
-x_304 = lean_ctor_get(x_299, 2);
+x_304 = lean_ctor_get(x_303, 3);
 lean_inc(x_304);
-if (lean_is_exclusive(x_299)) {
- lean_ctor_release(x_299, 0);
- lean_ctor_release(x_299, 1);
- lean_ctor_release(x_299, 2);
- lean_ctor_release(x_299, 3);
- x_305 = x_299;
-} else {
- lean_dec_ref(x_299);
- x_305 = lean_box(0);
-}
-x_306 = lean_ctor_get(x_300, 0);
+x_305 = lean_ctor_get(x_302, 1);
+lean_inc(x_305);
+lean_dec(x_302);
+x_306 = lean_ctor_get(x_303, 0);
 lean_inc(x_306);
-if (lean_is_exclusive(x_300)) {
- lean_ctor_release(x_300, 0);
- x_307 = x_300;
+x_307 = lean_ctor_get(x_303, 1);
+lean_inc(x_307);
+x_308 = lean_ctor_get(x_303, 2);
+lean_inc(x_308);
+if (lean_is_exclusive(x_303)) {
+ lean_ctor_release(x_303, 0);
+ lean_ctor_release(x_303, 1);
+ lean_ctor_release(x_303, 2);
+ lean_ctor_release(x_303, 3);
+ x_309 = x_303;
 } else {
- lean_dec_ref(x_300);
- x_307 = lean_box(0);
+ lean_dec_ref(x_303);
+ x_309 = lean_box(0);
 }
-if (lean_is_scalar(x_307)) {
- x_308 = lean_alloc_ctor(0, 1, 1);
+x_310 = lean_ctor_get(x_304, 0);
+lean_inc(x_310);
+if (lean_is_exclusive(x_304)) {
+ lean_ctor_release(x_304, 0);
+ x_311 = x_304;
 } else {
- x_308 = x_307;
+ lean_dec_ref(x_304);
+ x_311 = lean_box(0);
 }
-lean_ctor_set(x_308, 0, x_306);
-lean_ctor_set_uint8(x_308, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_305)) {
- x_309 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_311)) {
+ x_312 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_309 = x_305;
+ x_312 = x_311;
 }
-lean_ctor_set(x_309, 0, x_302);
-lean_ctor_set(x_309, 1, x_303);
-lean_ctor_set(x_309, 2, x_304);
-lean_ctor_set(x_309, 3, x_308);
-x_310 = lean_st_ref_set(x_5, x_309, x_301);
+lean_ctor_set(x_312, 0, x_310);
+lean_ctor_set_uint8(x_312, sizeof(void*)*1, x_13);
+if (lean_is_scalar(x_309)) {
+ x_313 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_313 = x_309;
+}
+lean_ctor_set(x_313, 0, x_306);
+lean_ctor_set(x_313, 1, x_307);
+lean_ctor_set(x_313, 2, x_308);
+lean_ctor_set(x_313, 3, x_312);
+x_314 = lean_st_ref_set(x_5, x_313, x_305);
 lean_dec(x_5);
-x_311 = lean_ctor_get(x_310, 1);
-lean_inc(x_311);
-if (lean_is_exclusive(x_310)) {
- lean_ctor_release(x_310, 0);
- lean_ctor_release(x_310, 1);
- x_312 = x_310;
-} else {
- lean_dec_ref(x_310);
- x_312 = lean_box(0);
-}
-if (lean_is_scalar(x_312)) {
- x_313 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_313 = x_312;
-}
-lean_ctor_set(x_313, 0, x_294);
-lean_ctor_set(x_313, 1, x_311);
-return x_313;
-}
-else
-{
-lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; 
-x_314 = lean_ctor_get(x_293, 0);
-lean_inc(x_314);
-x_315 = lean_ctor_get(x_293, 1);
+x_315 = lean_ctor_get(x_314, 1);
 lean_inc(x_315);
-lean_dec(x_293);
-x_316 = lean_st_ref_get(x_5, x_315);
-x_317 = lean_ctor_get(x_316, 1);
-lean_inc(x_317);
-lean_dec(x_316);
-x_318 = lean_st_ref_take(x_5, x_317);
-x_319 = lean_ctor_get(x_318, 0);
+if (lean_is_exclusive(x_314)) {
+ lean_ctor_release(x_314, 0);
+ lean_ctor_release(x_314, 1);
+ x_316 = x_314;
+} else {
+ lean_dec_ref(x_314);
+ x_316 = lean_box(0);
+}
+if (lean_is_scalar(x_316)) {
+ x_317 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_317 = x_316;
+}
+lean_ctor_set(x_317, 0, x_298);
+lean_ctor_set(x_317, 1, x_315);
+return x_317;
+}
+else
+{
+lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; 
+x_318 = lean_ctor_get(x_297, 0);
+lean_inc(x_318);
+x_319 = lean_ctor_get(x_297, 1);
 lean_inc(x_319);
-x_320 = lean_ctor_get(x_319, 3);
-lean_inc(x_320);
-x_321 = lean_ctor_get(x_318, 1);
+lean_dec(x_297);
+x_320 = lean_st_ref_get(x_5, x_319);
+x_321 = lean_ctor_get(x_320, 1);
 lean_inc(x_321);
-lean_dec(x_318);
-x_322 = lean_ctor_get(x_319, 0);
-lean_inc(x_322);
-x_323 = lean_ctor_get(x_319, 1);
+lean_dec(x_320);
+x_322 = lean_st_ref_take(x_5, x_321);
+x_323 = lean_ctor_get(x_322, 0);
 lean_inc(x_323);
-x_324 = lean_ctor_get(x_319, 2);
+x_324 = lean_ctor_get(x_323, 3);
 lean_inc(x_324);
-if (lean_is_exclusive(x_319)) {
- lean_ctor_release(x_319, 0);
- lean_ctor_release(x_319, 1);
- lean_ctor_release(x_319, 2);
- lean_ctor_release(x_319, 3);
- x_325 = x_319;
-} else {
- lean_dec_ref(x_319);
- x_325 = lean_box(0);
-}
-x_326 = lean_ctor_get(x_320, 0);
+x_325 = lean_ctor_get(x_322, 1);
+lean_inc(x_325);
+lean_dec(x_322);
+x_326 = lean_ctor_get(x_323, 0);
 lean_inc(x_326);
-if (lean_is_exclusive(x_320)) {
- lean_ctor_release(x_320, 0);
- x_327 = x_320;
+x_327 = lean_ctor_get(x_323, 1);
+lean_inc(x_327);
+x_328 = lean_ctor_get(x_323, 2);
+lean_inc(x_328);
+if (lean_is_exclusive(x_323)) {
+ lean_ctor_release(x_323, 0);
+ lean_ctor_release(x_323, 1);
+ lean_ctor_release(x_323, 2);
+ lean_ctor_release(x_323, 3);
+ x_329 = x_323;
 } else {
- lean_dec_ref(x_320);
- x_327 = lean_box(0);
+ lean_dec_ref(x_323);
+ x_329 = lean_box(0);
 }
-if (lean_is_scalar(x_327)) {
- x_328 = lean_alloc_ctor(0, 1, 1);
+x_330 = lean_ctor_get(x_324, 0);
+lean_inc(x_330);
+if (lean_is_exclusive(x_324)) {
+ lean_ctor_release(x_324, 0);
+ x_331 = x_324;
 } else {
- x_328 = x_327;
+ lean_dec_ref(x_324);
+ x_331 = lean_box(0);
 }
-lean_ctor_set(x_328, 0, x_326);
-lean_ctor_set_uint8(x_328, sizeof(void*)*1, x_13);
-if (lean_is_scalar(x_325)) {
- x_329 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_331)) {
+ x_332 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_329 = x_325;
+ x_332 = x_331;
 }
-lean_ctor_set(x_329, 0, x_322);
-lean_ctor_set(x_329, 1, x_323);
-lean_ctor_set(x_329, 2, x_324);
-lean_ctor_set(x_329, 3, x_328);
-x_330 = lean_st_ref_set(x_5, x_329, x_321);
+lean_ctor_set(x_332, 0, x_330);
+lean_ctor_set_uint8(x_332, sizeof(void*)*1, x_13);
+if (lean_is_scalar(x_329)) {
+ x_333 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_333 = x_329;
+}
+lean_ctor_set(x_333, 0, x_326);
+lean_ctor_set(x_333, 1, x_327);
+lean_ctor_set(x_333, 2, x_328);
+lean_ctor_set(x_333, 3, x_332);
+x_334 = lean_st_ref_set(x_5, x_333, x_325);
 lean_dec(x_5);
-x_331 = lean_ctor_get(x_330, 1);
-lean_inc(x_331);
-if (lean_is_exclusive(x_330)) {
- lean_ctor_release(x_330, 0);
- lean_ctor_release(x_330, 1);
- x_332 = x_330;
+x_335 = lean_ctor_get(x_334, 1);
+lean_inc(x_335);
+if (lean_is_exclusive(x_334)) {
+ lean_ctor_release(x_334, 0);
+ lean_ctor_release(x_334, 1);
+ x_336 = x_334;
 } else {
- lean_dec_ref(x_330);
- x_332 = lean_box(0);
+ lean_dec_ref(x_334);
+ x_336 = lean_box(0);
 }
-if (lean_is_scalar(x_332)) {
- x_333 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_336)) {
+ x_337 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_333 = x_332;
- lean_ctor_set_tag(x_333, 1);
+ x_337 = x_336;
+ lean_ctor_set_tag(x_337, 1);
 }
-lean_ctor_set(x_333, 0, x_314);
-lean_ctor_set(x_333, 1, x_331);
-return x_333;
+lean_ctor_set(x_337, 0, x_318);
+lean_ctor_set(x_337, 1, x_335);
+return x_337;
 }
 }
 }
 else
 {
-lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; uint8_t x_342; 
-x_334 = lean_ctor_get(x_4, 3);
-lean_inc(x_334);
-x_335 = l___private_Lean_Util_Trace_0__Lean_getResetTraces___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__6___rarg(x_5, x_8);
-x_336 = lean_ctor_get(x_2, 0);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_335, 0);
-lean_inc(x_337);
-x_338 = lean_ctor_get(x_335, 1);
+lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; uint8_t x_346; 
+x_338 = lean_ctor_get(x_4, 3);
 lean_inc(x_338);
-lean_dec(x_335);
-x_339 = lean_ctor_get(x_2, 1);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_2, 2);
+x_339 = l___private_Lean_Util_Trace_0__Lean_getResetTraces___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__6___rarg(x_5, x_8);
+x_340 = lean_ctor_get(x_2, 0);
 lean_inc(x_340);
-x_341 = lean_ctor_get(x_2, 3);
+x_341 = lean_ctor_get(x_339, 0);
 lean_inc(x_341);
-x_342 = !lean_is_exclusive(x_336);
-if (x_342 == 0)
+x_342 = lean_ctor_get(x_339, 1);
+lean_inc(x_342);
+lean_dec(x_339);
+x_343 = lean_ctor_get(x_2, 1);
+lean_inc(x_343);
+x_344 = lean_ctor_get(x_2, 2);
+lean_inc(x_344);
+x_345 = lean_ctor_get(x_2, 3);
+lean_inc(x_345);
+x_346 = !lean_is_exclusive(x_340);
+if (x_346 == 0)
 {
-uint8_t x_343; lean_object* x_344; lean_object* x_345; 
-x_343 = 0;
-lean_ctor_set_uint8(x_336, 5, x_343);
-x_344 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_344, 0, x_336);
-lean_ctor_set(x_344, 1, x_339);
-lean_ctor_set(x_344, 2, x_340);
-lean_ctor_set(x_344, 3, x_341);
+uint8_t x_347; lean_object* x_348; lean_object* x_349; 
+x_347 = 0;
+lean_ctor_set_uint8(x_340, 5, x_347);
+x_348 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_348, 0, x_340);
+lean_ctor_set(x_348, 1, x_343);
+lean_ctor_set(x_348, 2, x_344);
+lean_ctor_set(x_348, 3, x_345);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_345 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_344, x_3, x_4, x_5, x_338);
-if (lean_obj_tag(x_345) == 0)
+x_349 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_348, x_3, x_4, x_5, x_342);
+if (lean_obj_tag(x_349) == 0)
 {
-lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; uint8_t x_350; 
-x_346 = lean_ctor_get(x_345, 0);
-lean_inc(x_346);
-x_347 = lean_ctor_get(x_345, 1);
-lean_inc(x_347);
-lean_dec(x_345);
-x_348 = l_Lean_Meta_check___closed__2;
-x_349 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_337, x_348, x_334, x_2, x_3, x_4, x_5, x_347);
+lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; uint8_t x_354; 
+x_350 = lean_ctor_get(x_349, 0);
+lean_inc(x_350);
+x_351 = lean_ctor_get(x_349, 1);
+lean_inc(x_351);
+lean_dec(x_349);
+x_352 = l_Lean_Meta_check___closed__2;
+x_353 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_341, x_352, x_338, x_2, x_3, x_4, x_5, x_351);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_350 = !lean_is_exclusive(x_349);
-if (x_350 == 0)
+x_354 = !lean_is_exclusive(x_353);
+if (x_354 == 0)
 {
-lean_object* x_351; 
-x_351 = lean_ctor_get(x_349, 0);
-lean_dec(x_351);
-lean_ctor_set(x_349, 0, x_346);
-return x_349;
-}
-else
-{
-lean_object* x_352; lean_object* x_353; 
-x_352 = lean_ctor_get(x_349, 1);
-lean_inc(x_352);
-lean_dec(x_349);
-x_353 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_353, 0, x_346);
-lean_ctor_set(x_353, 1, x_352);
+lean_object* x_355; 
+x_355 = lean_ctor_get(x_353, 0);
+lean_dec(x_355);
+lean_ctor_set(x_353, 0, x_350);
 return x_353;
 }
+else
+{
+lean_object* x_356; lean_object* x_357; 
+x_356 = lean_ctor_get(x_353, 1);
+lean_inc(x_356);
+lean_dec(x_353);
+x_357 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_357, 0, x_350);
+lean_ctor_set(x_357, 1, x_356);
+return x_357;
+}
 }
 else
 {
-lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; uint8_t x_358; 
-x_354 = lean_ctor_get(x_345, 0);
-lean_inc(x_354);
-x_355 = lean_ctor_get(x_345, 1);
-lean_inc(x_355);
-lean_dec(x_345);
-x_356 = l_Lean_Meta_check___closed__2;
-x_357 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_337, x_356, x_334, x_2, x_3, x_4, x_5, x_355);
+lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; 
+x_358 = lean_ctor_get(x_349, 0);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_349, 1);
+lean_inc(x_359);
+lean_dec(x_349);
+x_360 = l_Lean_Meta_check___closed__2;
+x_361 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_341, x_360, x_338, x_2, x_3, x_4, x_5, x_359);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_358 = !lean_is_exclusive(x_357);
-if (x_358 == 0)
+x_362 = !lean_is_exclusive(x_361);
+if (x_362 == 0)
 {
-lean_object* x_359; 
-x_359 = lean_ctor_get(x_357, 0);
-lean_dec(x_359);
-lean_ctor_set_tag(x_357, 1);
-lean_ctor_set(x_357, 0, x_354);
-return x_357;
-}
-else
-{
-lean_object* x_360; lean_object* x_361; 
-x_360 = lean_ctor_get(x_357, 1);
-lean_inc(x_360);
-lean_dec(x_357);
-x_361 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_361, 0, x_354);
-lean_ctor_set(x_361, 1, x_360);
+lean_object* x_363; 
+x_363 = lean_ctor_get(x_361, 0);
+lean_dec(x_363);
+lean_ctor_set_tag(x_361, 1);
+lean_ctor_set(x_361, 0, x_358);
 return x_361;
 }
+else
+{
+lean_object* x_364; lean_object* x_365; 
+x_364 = lean_ctor_get(x_361, 1);
+lean_inc(x_364);
+lean_dec(x_361);
+x_365 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_365, 0, x_358);
+lean_ctor_set(x_365, 1, x_364);
+return x_365;
+}
 }
 }
 else
 {
-uint8_t x_362; uint8_t x_363; uint8_t x_364; uint8_t x_365; uint8_t x_366; uint8_t x_367; uint8_t x_368; uint8_t x_369; uint8_t x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; 
-x_362 = lean_ctor_get_uint8(x_336, 0);
-x_363 = lean_ctor_get_uint8(x_336, 1);
-x_364 = lean_ctor_get_uint8(x_336, 2);
-x_365 = lean_ctor_get_uint8(x_336, 3);
-x_366 = lean_ctor_get_uint8(x_336, 4);
-x_367 = lean_ctor_get_uint8(x_336, 6);
-x_368 = lean_ctor_get_uint8(x_336, 7);
-x_369 = lean_ctor_get_uint8(x_336, 8);
-lean_dec(x_336);
-x_370 = 0;
-x_371 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_371, 0, x_362);
-lean_ctor_set_uint8(x_371, 1, x_363);
-lean_ctor_set_uint8(x_371, 2, x_364);
-lean_ctor_set_uint8(x_371, 3, x_365);
-lean_ctor_set_uint8(x_371, 4, x_366);
-lean_ctor_set_uint8(x_371, 5, x_370);
-lean_ctor_set_uint8(x_371, 6, x_367);
-lean_ctor_set_uint8(x_371, 7, x_368);
-lean_ctor_set_uint8(x_371, 8, x_369);
-x_372 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_372, 0, x_371);
-lean_ctor_set(x_372, 1, x_339);
-lean_ctor_set(x_372, 2, x_340);
-lean_ctor_set(x_372, 3, x_341);
+uint8_t x_366; uint8_t x_367; uint8_t x_368; uint8_t x_369; uint8_t x_370; uint8_t x_371; uint8_t x_372; uint8_t x_373; uint8_t x_374; uint8_t x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; 
+x_366 = lean_ctor_get_uint8(x_340, 0);
+x_367 = lean_ctor_get_uint8(x_340, 1);
+x_368 = lean_ctor_get_uint8(x_340, 2);
+x_369 = lean_ctor_get_uint8(x_340, 3);
+x_370 = lean_ctor_get_uint8(x_340, 4);
+x_371 = lean_ctor_get_uint8(x_340, 6);
+x_372 = lean_ctor_get_uint8(x_340, 7);
+x_373 = lean_ctor_get_uint8(x_340, 8);
+x_374 = lean_ctor_get_uint8(x_340, 9);
+lean_dec(x_340);
+x_375 = 0;
+x_376 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_376, 0, x_366);
+lean_ctor_set_uint8(x_376, 1, x_367);
+lean_ctor_set_uint8(x_376, 2, x_368);
+lean_ctor_set_uint8(x_376, 3, x_369);
+lean_ctor_set_uint8(x_376, 4, x_370);
+lean_ctor_set_uint8(x_376, 5, x_375);
+lean_ctor_set_uint8(x_376, 6, x_371);
+lean_ctor_set_uint8(x_376, 7, x_372);
+lean_ctor_set_uint8(x_376, 8, x_373);
+lean_ctor_set_uint8(x_376, 9, x_374);
+x_377 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_377, 0, x_376);
+lean_ctor_set(x_377, 1, x_343);
+lean_ctor_set(x_377, 2, x_344);
+lean_ctor_set(x_377, 3, x_345);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_373 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_372, x_3, x_4, x_5, x_338);
-if (lean_obj_tag(x_373) == 0)
+x_378 = l___private_Lean_Meta_Check_0__Lean_Meta_checkAux(x_1, x_377, x_3, x_4, x_5, x_342);
+if (lean_obj_tag(x_378) == 0)
 {
-lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; 
-x_374 = lean_ctor_get(x_373, 0);
-lean_inc(x_374);
-x_375 = lean_ctor_get(x_373, 1);
-lean_inc(x_375);
-lean_dec(x_373);
-x_376 = l_Lean_Meta_check___closed__2;
-x_377 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_337, x_376, x_334, x_2, x_3, x_4, x_5, x_375);
+lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; 
+x_379 = lean_ctor_get(x_378, 0);
+lean_inc(x_379);
+x_380 = lean_ctor_get(x_378, 1);
+lean_inc(x_380);
+lean_dec(x_378);
+x_381 = l_Lean_Meta_check___closed__2;
+x_382 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_341, x_381, x_338, x_2, x_3, x_4, x_5, x_380);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_378 = lean_ctor_get(x_377, 1);
-lean_inc(x_378);
-if (lean_is_exclusive(x_377)) {
- lean_ctor_release(x_377, 0);
- lean_ctor_release(x_377, 1);
- x_379 = x_377;
+x_383 = lean_ctor_get(x_382, 1);
+lean_inc(x_383);
+if (lean_is_exclusive(x_382)) {
+ lean_ctor_release(x_382, 0);
+ lean_ctor_release(x_382, 1);
+ x_384 = x_382;
 } else {
- lean_dec_ref(x_377);
- x_379 = lean_box(0);
+ lean_dec_ref(x_382);
+ x_384 = lean_box(0);
 }
-if (lean_is_scalar(x_379)) {
- x_380 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_384)) {
+ x_385 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_380 = x_379;
+ x_385 = x_384;
 }
-lean_ctor_set(x_380, 0, x_374);
-lean_ctor_set(x_380, 1, x_378);
-return x_380;
+lean_ctor_set(x_385, 0, x_379);
+lean_ctor_set(x_385, 1, x_383);
+return x_385;
 }
 else
 {
-lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_381 = lean_ctor_get(x_373, 0);
-lean_inc(x_381);
-x_382 = lean_ctor_get(x_373, 1);
-lean_inc(x_382);
-lean_dec(x_373);
-x_383 = l_Lean_Meta_check___closed__2;
-x_384 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_337, x_383, x_334, x_2, x_3, x_4, x_5, x_382);
+lean_object* x_386; lean_object* x_387; lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; 
+x_386 = lean_ctor_get(x_378, 0);
+lean_inc(x_386);
+x_387 = lean_ctor_get(x_378, 1);
+lean_inc(x_387);
+lean_dec(x_378);
+x_388 = l_Lean_Meta_check___closed__2;
+x_389 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_341, x_388, x_338, x_2, x_3, x_4, x_5, x_387);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_385 = lean_ctor_get(x_384, 1);
-lean_inc(x_385);
-if (lean_is_exclusive(x_384)) {
- lean_ctor_release(x_384, 0);
- lean_ctor_release(x_384, 1);
- x_386 = x_384;
+x_390 = lean_ctor_get(x_389, 1);
+lean_inc(x_390);
+if (lean_is_exclusive(x_389)) {
+ lean_ctor_release(x_389, 0);
+ lean_ctor_release(x_389, 1);
+ x_391 = x_389;
 } else {
- lean_dec_ref(x_384);
- x_386 = lean_box(0);
+ lean_dec_ref(x_389);
+ x_391 = lean_box(0);
 }
-if (lean_is_scalar(x_386)) {
- x_387 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_391)) {
+ x_392 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_387 = x_386;
- lean_ctor_set_tag(x_387, 1);
+ x_392 = x_391;
+ lean_ctor_set_tag(x_392, 1);
 }
-lean_ctor_set(x_387, 0, x_381);
-lean_ctor_set(x_387, 1, x_385);
-return x_387;
+lean_ctor_set(x_392, 0, x_386);
+lean_ctor_set(x_392, 1, x_390);
+return x_392;
 }
 }
 }
@@ -5749,7 +5759,7 @@ static lean_object* _init_l_Lean_Meta_isTypeCorrect___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Meta_isTypeCorrect___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
diff --git a/stage0/stdlib/Lean/Meta/Closure.c b/stage0/stdlib/Lean/Meta/Closure.c
index ecb98092a3..ac6eda292c 100644
--- a/stage0/stdlib/Lean/Meta/Closure.c
+++ b/stage0/stdlib/Lean/Meta/Closure.c
@@ -106,12 +106,12 @@ lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Meta_Closure_visitLevel___spec_
 lean_object* l_Lean_Meta_Closure_State_visitedLevel___default;
 lean_object* l_Array_back___at_Lean_Meta_Closure_pickNextToProcess_x3f___spec__1(lean_object*);
 lean_object* l_Lean_Meta_Closure_collectExprAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 lean_object* l_Lean_compileDecl___at_Lean_Meta_mkAuxDefinition___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Level_updateSucc_x21___closed__3;
 lean_object* l_Lean_Meta_Closure_process___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* lean_expr_abstract_range(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
 lean_object* l_Lean_mkFreshId___at_Lean_Meta_Closure_collectExprAux___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_Closure_process___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Level_updateMax_x21___closed__3;
@@ -12729,7 +12729,7 @@ return x_41;
 }
 else
 {
-uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; lean_object* x_51; lean_object* x_52; 
+uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; lean_object* x_52; lean_object* x_53; 
 x_42 = lean_ctor_get_uint8(x_11, 0);
 x_43 = lean_ctor_get_uint8(x_11, 1);
 x_44 = lean_ctor_get_uint8(x_11, 2);
@@ -12738,340 +12738,344 @@ x_46 = lean_ctor_get_uint8(x_11, 4);
 x_47 = lean_ctor_get_uint8(x_11, 5);
 x_48 = lean_ctor_get_uint8(x_11, 6);
 x_49 = lean_ctor_get_uint8(x_11, 8);
+x_50 = lean_ctor_get_uint8(x_11, 9);
 lean_dec(x_11);
-x_50 = 1;
-x_51 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_51, 0, x_42);
-lean_ctor_set_uint8(x_51, 1, x_43);
-lean_ctor_set_uint8(x_51, 2, x_44);
-lean_ctor_set_uint8(x_51, 3, x_45);
-lean_ctor_set_uint8(x_51, 4, x_46);
-lean_ctor_set_uint8(x_51, 5, x_47);
-lean_ctor_set_uint8(x_51, 6, x_48);
-lean_ctor_set_uint8(x_51, 7, x_50);
-lean_ctor_set_uint8(x_51, 8, x_49);
-lean_ctor_set(x_5, 0, x_51);
+x_51 = 1;
+x_52 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_52, 0, x_42);
+lean_ctor_set_uint8(x_52, 1, x_43);
+lean_ctor_set_uint8(x_52, 2, x_44);
+lean_ctor_set_uint8(x_52, 3, x_45);
+lean_ctor_set_uint8(x_52, 4, x_46);
+lean_ctor_set_uint8(x_52, 5, x_47);
+lean_ctor_set_uint8(x_52, 6, x_48);
+lean_ctor_set_uint8(x_52, 7, x_51);
+lean_ctor_set_uint8(x_52, 8, x_49);
+lean_ctor_set_uint8(x_52, 9, x_50);
+lean_ctor_set(x_5, 0, x_52);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-x_52 = l_Lean_Meta_Closure_collectExpr(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_12);
-if (lean_obj_tag(x_52) == 0)
+x_53 = l_Lean_Meta_Closure_collectExpr(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_12);
+if (lean_obj_tag(x_53) == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_53 = lean_ctor_get(x_52, 0);
-lean_inc(x_53);
-x_54 = lean_ctor_get(x_52, 1);
+lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+x_54 = lean_ctor_get(x_53, 0);
 lean_inc(x_54);
-lean_dec(x_52);
+x_55 = lean_ctor_get(x_53, 1);
+lean_inc(x_55);
+lean_dec(x_53);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-x_55 = l_Lean_Meta_Closure_collectExpr(x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_54);
-if (lean_obj_tag(x_55) == 0)
+x_56 = l_Lean_Meta_Closure_collectExpr(x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_55);
+if (lean_obj_tag(x_56) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 1);
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_57 = lean_ctor_get(x_56, 0);
 lean_inc(x_57);
-lean_dec(x_55);
-x_58 = l_Lean_Meta_Closure_process(x_3, x_4, x_5, x_6, x_7, x_8, x_57);
-if (lean_obj_tag(x_58) == 0)
-{
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-x_59 = lean_ctor_get(x_58, 1);
-lean_inc(x_59);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_60 = x_58;
-} else {
- lean_dec_ref(x_58);
- x_60 = lean_box(0);
-}
-x_61 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_61, 0, x_53);
-lean_ctor_set(x_61, 1, x_56);
-if (lean_is_scalar(x_60)) {
- x_62 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_62 = x_60;
-}
-lean_ctor_set(x_62, 0, x_61);
-lean_ctor_set(x_62, 1, x_59);
-return x_62;
-}
-else
-{
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_58 = lean_ctor_get(x_56, 1);
+lean_inc(x_58);
 lean_dec(x_56);
-lean_dec(x_53);
-x_63 = lean_ctor_get(x_58, 0);
-lean_inc(x_63);
-x_64 = lean_ctor_get(x_58, 1);
+x_59 = l_Lean_Meta_Closure_process(x_3, x_4, x_5, x_6, x_7, x_8, x_58);
+if (lean_obj_tag(x_59) == 0)
+{
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_60 = lean_ctor_get(x_59, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ x_61 = x_59;
+} else {
+ lean_dec_ref(x_59);
+ x_61 = lean_box(0);
+}
+x_62 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_62, 0, x_54);
+lean_ctor_set(x_62, 1, x_57);
+if (lean_is_scalar(x_61)) {
+ x_63 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_63 = x_61;
+}
+lean_ctor_set(x_63, 0, x_62);
+lean_ctor_set(x_63, 1, x_60);
+return x_63;
+}
+else
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+lean_dec(x_57);
+lean_dec(x_54);
+x_64 = lean_ctor_get(x_59, 0);
 lean_inc(x_64);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_65 = x_58;
+x_65 = lean_ctor_get(x_59, 1);
+lean_inc(x_65);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ x_66 = x_59;
 } else {
- lean_dec_ref(x_58);
- x_65 = lean_box(0);
+ lean_dec_ref(x_59);
+ x_66 = lean_box(0);
 }
-if (lean_is_scalar(x_65)) {
- x_66 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_66)) {
+ x_67 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_66 = x_65;
+ x_67 = x_66;
 }
-lean_ctor_set(x_66, 0, x_63);
-lean_ctor_set(x_66, 1, x_64);
-return x_66;
+lean_ctor_set(x_67, 0, x_64);
+lean_ctor_set(x_67, 1, x_65);
+return x_67;
 }
 }
 else
 {
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-lean_dec(x_53);
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+lean_dec(x_54);
 lean_dec(x_5);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
-x_67 = lean_ctor_get(x_55, 0);
-lean_inc(x_67);
-x_68 = lean_ctor_get(x_55, 1);
+x_68 = lean_ctor_get(x_56, 0);
 lean_inc(x_68);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_69 = x_55;
+x_69 = lean_ctor_get(x_56, 1);
+lean_inc(x_69);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ x_70 = x_56;
 } else {
- lean_dec_ref(x_55);
- x_69 = lean_box(0);
+ lean_dec_ref(x_56);
+ x_70 = lean_box(0);
 }
-if (lean_is_scalar(x_69)) {
- x_70 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_70)) {
+ x_71 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_70 = x_69;
+ x_71 = x_70;
 }
-lean_ctor_set(x_70, 0, x_67);
-lean_ctor_set(x_70, 1, x_68);
-return x_70;
+lean_ctor_set(x_71, 0, x_68);
+lean_ctor_set(x_71, 1, x_69);
+return x_71;
 }
 }
 else
 {
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
 lean_dec(x_5);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_2);
-x_71 = lean_ctor_get(x_52, 0);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_52, 1);
+x_72 = lean_ctor_get(x_53, 0);
 lean_inc(x_72);
-if (lean_is_exclusive(x_52)) {
- lean_ctor_release(x_52, 0);
- lean_ctor_release(x_52, 1);
- x_73 = x_52;
+x_73 = lean_ctor_get(x_53, 1);
+lean_inc(x_73);
+if (lean_is_exclusive(x_53)) {
+ lean_ctor_release(x_53, 0);
+ lean_ctor_release(x_53, 1);
+ x_74 = x_53;
 } else {
- lean_dec_ref(x_52);
- x_73 = lean_box(0);
+ lean_dec_ref(x_53);
+ x_74 = lean_box(0);
 }
-if (lean_is_scalar(x_73)) {
- x_74 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_74)) {
+ x_75 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_74 = x_73;
+ x_75 = x_74;
 }
-lean_ctor_set(x_74, 0, x_71);
-lean_ctor_set(x_74, 1, x_72);
-return x_74;
+lean_ctor_set(x_75, 0, x_72);
+lean_ctor_set(x_75, 1, x_73);
+return x_75;
 }
 }
 }
 else
 {
-lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; uint8_t x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; lean_object* x_86; uint8_t x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-x_75 = lean_ctor_get(x_5, 1);
-x_76 = lean_ctor_get(x_5, 2);
-x_77 = lean_ctor_get(x_5, 3);
+lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; lean_object* x_88; uint8_t x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+x_76 = lean_ctor_get(x_5, 1);
+x_77 = lean_ctor_get(x_5, 2);
+x_78 = lean_ctor_get(x_5, 3);
+lean_inc(x_78);
 lean_inc(x_77);
 lean_inc(x_76);
-lean_inc(x_75);
 lean_dec(x_5);
-x_78 = lean_ctor_get_uint8(x_11, 0);
-x_79 = lean_ctor_get_uint8(x_11, 1);
-x_80 = lean_ctor_get_uint8(x_11, 2);
-x_81 = lean_ctor_get_uint8(x_11, 3);
-x_82 = lean_ctor_get_uint8(x_11, 4);
-x_83 = lean_ctor_get_uint8(x_11, 5);
-x_84 = lean_ctor_get_uint8(x_11, 6);
-x_85 = lean_ctor_get_uint8(x_11, 8);
+x_79 = lean_ctor_get_uint8(x_11, 0);
+x_80 = lean_ctor_get_uint8(x_11, 1);
+x_81 = lean_ctor_get_uint8(x_11, 2);
+x_82 = lean_ctor_get_uint8(x_11, 3);
+x_83 = lean_ctor_get_uint8(x_11, 4);
+x_84 = lean_ctor_get_uint8(x_11, 5);
+x_85 = lean_ctor_get_uint8(x_11, 6);
+x_86 = lean_ctor_get_uint8(x_11, 8);
+x_87 = lean_ctor_get_uint8(x_11, 9);
 if (lean_is_exclusive(x_11)) {
- x_86 = x_11;
+ x_88 = x_11;
 } else {
  lean_dec_ref(x_11);
- x_86 = lean_box(0);
+ x_88 = lean_box(0);
 }
-x_87 = 1;
-if (lean_is_scalar(x_86)) {
- x_88 = lean_alloc_ctor(0, 0, 9);
+x_89 = 1;
+if (lean_is_scalar(x_88)) {
+ x_90 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_88 = x_86;
+ x_90 = x_88;
 }
-lean_ctor_set_uint8(x_88, 0, x_78);
-lean_ctor_set_uint8(x_88, 1, x_79);
-lean_ctor_set_uint8(x_88, 2, x_80);
-lean_ctor_set_uint8(x_88, 3, x_81);
-lean_ctor_set_uint8(x_88, 4, x_82);
-lean_ctor_set_uint8(x_88, 5, x_83);
-lean_ctor_set_uint8(x_88, 6, x_84);
-lean_ctor_set_uint8(x_88, 7, x_87);
-lean_ctor_set_uint8(x_88, 8, x_85);
-x_89 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_89, 0, x_88);
-lean_ctor_set(x_89, 1, x_75);
-lean_ctor_set(x_89, 2, x_76);
-lean_ctor_set(x_89, 3, x_77);
+lean_ctor_set_uint8(x_90, 0, x_79);
+lean_ctor_set_uint8(x_90, 1, x_80);
+lean_ctor_set_uint8(x_90, 2, x_81);
+lean_ctor_set_uint8(x_90, 3, x_82);
+lean_ctor_set_uint8(x_90, 4, x_83);
+lean_ctor_set_uint8(x_90, 5, x_84);
+lean_ctor_set_uint8(x_90, 6, x_85);
+lean_ctor_set_uint8(x_90, 7, x_89);
+lean_ctor_set_uint8(x_90, 8, x_86);
+lean_ctor_set_uint8(x_90, 9, x_87);
+x_91 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_91, 0, x_90);
+lean_ctor_set(x_91, 1, x_76);
+lean_ctor_set(x_91, 2, x_77);
+lean_ctor_set(x_91, 3, x_78);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-lean_inc(x_89);
-x_90 = l_Lean_Meta_Closure_collectExpr(x_1, x_3, x_4, x_89, x_6, x_7, x_8, x_12);
-if (lean_obj_tag(x_90) == 0)
-{
-lean_object* x_91; lean_object* x_92; lean_object* x_93; 
-x_91 = lean_ctor_get(x_90, 0);
 lean_inc(x_91);
-x_92 = lean_ctor_get(x_90, 1);
-lean_inc(x_92);
-lean_dec(x_90);
+x_92 = l_Lean_Meta_Closure_collectExpr(x_1, x_3, x_4, x_91, x_6, x_7, x_8, x_12);
+if (lean_obj_tag(x_92) == 0)
+{
+lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+x_93 = lean_ctor_get(x_92, 0);
+lean_inc(x_93);
+x_94 = lean_ctor_get(x_92, 1);
+lean_inc(x_94);
+lean_dec(x_92);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-lean_inc(x_89);
-x_93 = l_Lean_Meta_Closure_collectExpr(x_2, x_3, x_4, x_89, x_6, x_7, x_8, x_92);
-if (lean_obj_tag(x_93) == 0)
+lean_inc(x_91);
+x_95 = l_Lean_Meta_Closure_collectExpr(x_2, x_3, x_4, x_91, x_6, x_7, x_8, x_94);
+if (lean_obj_tag(x_95) == 0)
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; 
-x_94 = lean_ctor_get(x_93, 0);
-lean_inc(x_94);
-x_95 = lean_ctor_get(x_93, 1);
-lean_inc(x_95);
-lean_dec(x_93);
-x_96 = l_Lean_Meta_Closure_process(x_3, x_4, x_89, x_6, x_7, x_8, x_95);
-if (lean_obj_tag(x_96) == 0)
-{
-lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 
-x_97 = lean_ctor_get(x_96, 1);
+lean_object* x_96; lean_object* x_97; lean_object* x_98; 
+x_96 = lean_ctor_get(x_95, 0);
+lean_inc(x_96);
+x_97 = lean_ctor_get(x_95, 1);
 lean_inc(x_97);
-if (lean_is_exclusive(x_96)) {
- lean_ctor_release(x_96, 0);
- lean_ctor_release(x_96, 1);
- x_98 = x_96;
-} else {
- lean_dec_ref(x_96);
- x_98 = lean_box(0);
-}
-x_99 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_99, 0, x_91);
-lean_ctor_set(x_99, 1, x_94);
-if (lean_is_scalar(x_98)) {
- x_100 = lean_alloc_ctor(0, 2, 0);
-} else {
+lean_dec(x_95);
+x_98 = l_Lean_Meta_Closure_process(x_3, x_4, x_91, x_6, x_7, x_8, x_97);
+if (lean_obj_tag(x_98) == 0)
+{
+lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+x_99 = lean_ctor_get(x_98, 1);
+lean_inc(x_99);
+if (lean_is_exclusive(x_98)) {
+ lean_ctor_release(x_98, 0);
+ lean_ctor_release(x_98, 1);
  x_100 = x_98;
+} else {
+ lean_dec_ref(x_98);
+ x_100 = lean_box(0);
 }
-lean_ctor_set(x_100, 0, x_99);
-lean_ctor_set(x_100, 1, x_97);
-return x_100;
+x_101 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_101, 0, x_93);
+lean_ctor_set(x_101, 1, x_96);
+if (lean_is_scalar(x_100)) {
+ x_102 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_102 = x_100;
+}
+lean_ctor_set(x_102, 0, x_101);
+lean_ctor_set(x_102, 1, x_99);
+return x_102;
 }
 else
 {
-lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; 
-lean_dec(x_94);
-lean_dec(x_91);
-x_101 = lean_ctor_get(x_96, 0);
-lean_inc(x_101);
-x_102 = lean_ctor_get(x_96, 1);
-lean_inc(x_102);
-if (lean_is_exclusive(x_96)) {
- lean_ctor_release(x_96, 0);
- lean_ctor_release(x_96, 1);
- x_103 = x_96;
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; 
+lean_dec(x_96);
+lean_dec(x_93);
+x_103 = lean_ctor_get(x_98, 0);
+lean_inc(x_103);
+x_104 = lean_ctor_get(x_98, 1);
+lean_inc(x_104);
+if (lean_is_exclusive(x_98)) {
+ lean_ctor_release(x_98, 0);
+ lean_ctor_release(x_98, 1);
+ x_105 = x_98;
 } else {
- lean_dec_ref(x_96);
- x_103 = lean_box(0);
+ lean_dec_ref(x_98);
+ x_105 = lean_box(0);
 }
-if (lean_is_scalar(x_103)) {
- x_104 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_105)) {
+ x_106 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_104 = x_103;
+ x_106 = x_105;
 }
-lean_ctor_set(x_104, 0, x_101);
-lean_ctor_set(x_104, 1, x_102);
-return x_104;
+lean_ctor_set(x_106, 0, x_103);
+lean_ctor_set(x_106, 1, x_104);
+return x_106;
 }
 }
 else
 {
-lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
+lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; 
+lean_dec(x_93);
 lean_dec(x_91);
-lean_dec(x_89);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
-x_105 = lean_ctor_get(x_93, 0);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_93, 1);
-lean_inc(x_106);
-if (lean_is_exclusive(x_93)) {
- lean_ctor_release(x_93, 0);
- lean_ctor_release(x_93, 1);
- x_107 = x_93;
+x_107 = lean_ctor_get(x_95, 0);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_95, 1);
+lean_inc(x_108);
+if (lean_is_exclusive(x_95)) {
+ lean_ctor_release(x_95, 0);
+ lean_ctor_release(x_95, 1);
+ x_109 = x_95;
 } else {
- lean_dec_ref(x_93);
- x_107 = lean_box(0);
+ lean_dec_ref(x_95);
+ x_109 = lean_box(0);
 }
-if (lean_is_scalar(x_107)) {
- x_108 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_109)) {
+ x_110 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_108 = x_107;
+ x_110 = x_109;
 }
-lean_ctor_set(x_108, 0, x_105);
-lean_ctor_set(x_108, 1, x_106);
-return x_108;
+lean_ctor_set(x_110, 0, x_107);
+lean_ctor_set(x_110, 1, x_108);
+return x_110;
 }
 }
 else
 {
-lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
-lean_dec(x_89);
+lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; 
+lean_dec(x_91);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_2);
-x_109 = lean_ctor_get(x_90, 0);
-lean_inc(x_109);
-x_110 = lean_ctor_get(x_90, 1);
-lean_inc(x_110);
-if (lean_is_exclusive(x_90)) {
- lean_ctor_release(x_90, 0);
- lean_ctor_release(x_90, 1);
- x_111 = x_90;
+x_111 = lean_ctor_get(x_92, 0);
+lean_inc(x_111);
+x_112 = lean_ctor_get(x_92, 1);
+lean_inc(x_112);
+if (lean_is_exclusive(x_92)) {
+ lean_ctor_release(x_92, 0);
+ lean_ctor_release(x_92, 1);
+ x_113 = x_92;
 } else {
- lean_dec_ref(x_90);
- x_111 = lean_box(0);
+ lean_dec_ref(x_92);
+ x_113 = lean_box(0);
 }
-if (lean_is_scalar(x_111)) {
- x_112 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_113)) {
+ x_114 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_112 = x_111;
+ x_114 = x_113;
 }
-lean_ctor_set(x_112, 0, x_109);
-lean_ctor_set(x_112, 1, x_110);
-return x_112;
+lean_ctor_set(x_114, 0, x_111);
+lean_ctor_set(x_114, 1, x_112);
+return x_114;
 }
 }
 }
@@ -14331,55 +14335,74 @@ x_12 = lean_compile_decl(x_10, x_11, x_1);
 lean_dec(x_11);
 if (lean_obj_tag(x_12) == 0)
 {
-lean_object* x_13; lean_object* x_14; 
+lean_object* x_13; 
 x_13 = lean_ctor_get(x_12, 0);
 lean_inc(x_13);
 lean_dec(x_12);
-x_14 = l___private_Lean_MonadEnv_0__Lean_checkUnsupported___at_Lean_Meta_mkAuxDefinition___spec__4(x_1, x_2, x_3, x_4, x_5, x_9);
-if (lean_obj_tag(x_14) == 0)
+if (lean_obj_tag(x_13) == 11)
 {
-lean_object* x_15; lean_object* x_16; 
-x_15 = lean_ctor_get(x_14, 1);
-lean_inc(x_15);
-lean_dec(x_14);
-x_16 = l_Lean_throwKernelException___at_Lean_Meta_mkAuxDefinition___spec__2(x_13, x_2, x_3, x_4, x_5, x_15);
-return x_16;
-}
-else
-{
-uint8_t x_17; 
+lean_object* x_14; lean_object* x_15; 
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
 lean_dec(x_13);
-lean_dec(x_4);
-x_17 = !lean_is_exclusive(x_14);
-if (x_17 == 0)
+x_15 = l___private_Lean_MonadEnv_0__Lean_checkUnsupported___at_Lean_Meta_mkAuxDefinition___spec__4(x_1, x_2, x_3, x_4, x_5, x_9);
+if (lean_obj_tag(x_15) == 0)
 {
-return x_14;
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_16 = lean_ctor_get(x_15, 1);
+lean_inc(x_16);
+lean_dec(x_15);
+x_17 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_17, 0, x_14);
+x_18 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_18, 0, x_17);
+x_19 = l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(x_18, x_2, x_3, x_4, x_5, x_16);
+lean_dec(x_4);
+return x_19;
 }
 else
 {
-lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-x_18 = lean_ctor_get(x_14, 0);
-x_19 = lean_ctor_get(x_14, 1);
-lean_inc(x_19);
-lean_inc(x_18);
+uint8_t x_20; 
 lean_dec(x_14);
-x_20 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_20, 0, x_18);
-lean_ctor_set(x_20, 1, x_19);
-return x_20;
+lean_dec(x_4);
+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
 {
-lean_object* x_21; lean_object* x_22; 
+lean_object* x_24; 
 lean_dec(x_1);
-x_21 = lean_ctor_get(x_12, 0);
-lean_inc(x_21);
+x_24 = l_Lean_throwKernelException___at_Lean_Meta_mkAuxDefinition___spec__2(x_13, x_2, x_3, x_4, x_5, x_9);
+return x_24;
+}
+}
+else
+{
+lean_object* x_25; lean_object* x_26; 
+lean_dec(x_1);
+x_25 = lean_ctor_get(x_12, 0);
+lean_inc(x_25);
 lean_dec(x_12);
-x_22 = l_Lean_setEnv___at_Lean_Meta_setInlineAttribute___spec__2(x_21, x_2, x_3, x_4, x_5, x_9);
+x_26 = l_Lean_setEnv___at_Lean_Meta_setInlineAttribute___spec__2(x_25, x_2, x_3, x_4, x_5, x_9);
 lean_dec(x_4);
-return x_22;
+return x_26;
 }
 }
 }
@@ -14440,7 +14463,7 @@ lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119;
 x_116 = lean_ctor_get(x_110, 1);
 lean_inc(x_116);
 lean_dec(x_110);
-x_117 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_117 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_118 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_117, x_6, x_7, x_8, x_9, x_116);
 x_119 = lean_ctor_get(x_118, 0);
 lean_inc(x_119);
@@ -14567,7 +14590,7 @@ lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean
 x_76 = lean_ctor_get(x_30, 1);
 lean_inc(x_76);
 lean_dec(x_30);
-x_77 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_77 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_78 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_77, x_6, x_7, x_8, x_9, x_76);
 x_79 = lean_ctor_get(x_78, 0);
 lean_inc(x_79);
@@ -14726,7 +14749,7 @@ lean_ctor_set(x_65, 1, x_64);
 x_66 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_66, 0, x_65);
 lean_ctor_set(x_66, 1, x_56);
-x_67 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_67 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_68 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_67, x_66, x_6, x_7, x_8, x_9, x_54);
 x_69 = lean_ctor_get(x_68, 1);
 lean_inc(x_69);
@@ -14805,7 +14828,7 @@ lean_ctor_set(x_104, 1, x_103);
 x_105 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_105, 0, x_104);
 lean_ctor_set(x_105, 1, x_95);
-x_106 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_106 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_107 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_106, x_105, x_6, x_7, x_8, x_9, x_93);
 x_108 = lean_ctor_get(x_107, 1);
 lean_inc(x_108);
diff --git a/stage0/stdlib/Lean/Meta/Coe.c b/stage0/stdlib/Lean/Meta/Coe.c
index ecf766ab4b..654b465189 100644
--- a/stage0/stdlib/Lean/Meta/Coe.c
+++ b/stage0/stdlib/Lean/Meta/Coe.c
@@ -3277,7 +3277,7 @@ return x_21;
 }
 else
 {
-uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
 x_22 = lean_ctor_get_uint8(x_8, 0);
 x_23 = lean_ctor_get_uint8(x_8, 1);
 x_24 = lean_ctor_get_uint8(x_8, 2);
@@ -3286,168 +3286,172 @@ x_26 = lean_ctor_get_uint8(x_8, 4);
 x_27 = lean_ctor_get_uint8(x_8, 6);
 x_28 = lean_ctor_get_uint8(x_8, 7);
 x_29 = lean_ctor_get_uint8(x_8, 8);
+x_30 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_30 = 3;
-x_31 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_31, 0, x_22);
-lean_ctor_set_uint8(x_31, 1, x_23);
-lean_ctor_set_uint8(x_31, 2, x_24);
-lean_ctor_set_uint8(x_31, 3, x_25);
-lean_ctor_set_uint8(x_31, 4, x_26);
-lean_ctor_set_uint8(x_31, 5, x_30);
-lean_ctor_set_uint8(x_31, 6, x_27);
-lean_ctor_set_uint8(x_31, 7, x_28);
-lean_ctor_set_uint8(x_31, 8, x_29);
-lean_ctor_set(x_2, 0, x_31);
-x_32 = l_Lean_Meta_expandCoe___closed__1;
-x_33 = l_Lean_Meta_expandCoe___closed__2;
-x_34 = l_Lean_Meta_transform___at_Lean_Meta_expandCoe___spec__1(x_1, x_32, x_33, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_34) == 0)
+x_31 = 3;
+x_32 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_32, 0, x_22);
+lean_ctor_set_uint8(x_32, 1, x_23);
+lean_ctor_set_uint8(x_32, 2, x_24);
+lean_ctor_set_uint8(x_32, 3, x_25);
+lean_ctor_set_uint8(x_32, 4, x_26);
+lean_ctor_set_uint8(x_32, 5, x_31);
+lean_ctor_set_uint8(x_32, 6, x_27);
+lean_ctor_set_uint8(x_32, 7, x_28);
+lean_ctor_set_uint8(x_32, 8, x_29);
+lean_ctor_set_uint8(x_32, 9, x_30);
+lean_ctor_set(x_2, 0, x_32);
+x_33 = l_Lean_Meta_expandCoe___closed__1;
+x_34 = l_Lean_Meta_expandCoe___closed__2;
+x_35 = l_Lean_Meta_transform___at_Lean_Meta_expandCoe___spec__1(x_1, x_33, x_34, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_35) == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_35 = lean_ctor_get(x_34, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_34, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_36 = lean_ctor_get(x_35, 0);
 lean_inc(x_36);
-if (lean_is_exclusive(x_34)) {
- lean_ctor_release(x_34, 0);
- lean_ctor_release(x_34, 1);
- x_37 = x_34;
+x_37 = lean_ctor_get(x_35, 1);
+lean_inc(x_37);
+if (lean_is_exclusive(x_35)) {
+ lean_ctor_release(x_35, 0);
+ lean_ctor_release(x_35, 1);
+ x_38 = x_35;
 } else {
- lean_dec_ref(x_34);
- x_37 = lean_box(0);
+ lean_dec_ref(x_35);
+ x_38 = lean_box(0);
 }
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_38)) {
+ x_39 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_38 = x_37;
+ x_39 = x_38;
 }
-lean_ctor_set(x_38, 0, x_35);
-lean_ctor_set(x_38, 1, x_36);
-return x_38;
+lean_ctor_set(x_39, 0, x_36);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_39 = lean_ctor_get(x_34, 0);
-lean_inc(x_39);
-x_40 = lean_ctor_get(x_34, 1);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_40 = lean_ctor_get(x_35, 0);
 lean_inc(x_40);
-if (lean_is_exclusive(x_34)) {
- lean_ctor_release(x_34, 0);
- lean_ctor_release(x_34, 1);
- x_41 = x_34;
+x_41 = lean_ctor_get(x_35, 1);
+lean_inc(x_41);
+if (lean_is_exclusive(x_35)) {
+ lean_ctor_release(x_35, 0);
+ lean_ctor_release(x_35, 1);
+ x_42 = x_35;
 } else {
- lean_dec_ref(x_34);
- x_41 = lean_box(0);
+ lean_dec_ref(x_35);
+ x_42 = lean_box(0);
 }
-if (lean_is_scalar(x_41)) {
- x_42 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_42)) {
+ x_43 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_42 = x_41;
+ x_43 = x_42;
 }
-lean_ctor_set(x_42, 0, x_39);
-lean_ctor_set(x_42, 1, x_40);
-return x_42;
+lean_ctor_set(x_43, 0, x_40);
+lean_ctor_set(x_43, 1, x_41);
+return x_43;
 }
 }
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_43 = lean_ctor_get(x_2, 0);
-x_44 = lean_ctor_get(x_2, 1);
-x_45 = lean_ctor_get(x_2, 2);
-x_46 = lean_ctor_get(x_2, 3);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_44 = lean_ctor_get(x_2, 0);
+x_45 = lean_ctor_get(x_2, 1);
+x_46 = lean_ctor_get(x_2, 2);
+x_47 = lean_ctor_get(x_2, 3);
+lean_inc(x_47);
 lean_inc(x_46);
 lean_inc(x_45);
 lean_inc(x_44);
-lean_inc(x_43);
 lean_dec(x_2);
-x_47 = lean_ctor_get_uint8(x_43, 0);
-x_48 = lean_ctor_get_uint8(x_43, 1);
-x_49 = lean_ctor_get_uint8(x_43, 2);
-x_50 = lean_ctor_get_uint8(x_43, 3);
-x_51 = lean_ctor_get_uint8(x_43, 4);
-x_52 = lean_ctor_get_uint8(x_43, 6);
-x_53 = lean_ctor_get_uint8(x_43, 7);
-x_54 = lean_ctor_get_uint8(x_43, 8);
-if (lean_is_exclusive(x_43)) {
- x_55 = x_43;
+x_48 = lean_ctor_get_uint8(x_44, 0);
+x_49 = lean_ctor_get_uint8(x_44, 1);
+x_50 = lean_ctor_get_uint8(x_44, 2);
+x_51 = lean_ctor_get_uint8(x_44, 3);
+x_52 = lean_ctor_get_uint8(x_44, 4);
+x_53 = lean_ctor_get_uint8(x_44, 6);
+x_54 = lean_ctor_get_uint8(x_44, 7);
+x_55 = lean_ctor_get_uint8(x_44, 8);
+x_56 = lean_ctor_get_uint8(x_44, 9);
+if (lean_is_exclusive(x_44)) {
+ x_57 = x_44;
 } else {
- lean_dec_ref(x_43);
- x_55 = lean_box(0);
+ lean_dec_ref(x_44);
+ x_57 = lean_box(0);
 }
-x_56 = 3;
-if (lean_is_scalar(x_55)) {
- x_57 = lean_alloc_ctor(0, 0, 9);
+x_58 = 3;
+if (lean_is_scalar(x_57)) {
+ x_59 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_57 = x_55;
+ x_59 = x_57;
 }
-lean_ctor_set_uint8(x_57, 0, x_47);
-lean_ctor_set_uint8(x_57, 1, x_48);
-lean_ctor_set_uint8(x_57, 2, x_49);
-lean_ctor_set_uint8(x_57, 3, x_50);
-lean_ctor_set_uint8(x_57, 4, x_51);
-lean_ctor_set_uint8(x_57, 5, x_56);
-lean_ctor_set_uint8(x_57, 6, x_52);
-lean_ctor_set_uint8(x_57, 7, x_53);
-lean_ctor_set_uint8(x_57, 8, x_54);
-x_58 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set(x_58, 1, x_44);
-lean_ctor_set(x_58, 2, x_45);
-lean_ctor_set(x_58, 3, x_46);
-x_59 = l_Lean_Meta_expandCoe___closed__1;
-x_60 = l_Lean_Meta_expandCoe___closed__2;
-x_61 = l_Lean_Meta_transform___at_Lean_Meta_expandCoe___spec__1(x_1, x_59, x_60, x_58, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_61) == 0)
+lean_ctor_set_uint8(x_59, 0, x_48);
+lean_ctor_set_uint8(x_59, 1, x_49);
+lean_ctor_set_uint8(x_59, 2, x_50);
+lean_ctor_set_uint8(x_59, 3, x_51);
+lean_ctor_set_uint8(x_59, 4, x_52);
+lean_ctor_set_uint8(x_59, 5, x_58);
+lean_ctor_set_uint8(x_59, 6, x_53);
+lean_ctor_set_uint8(x_59, 7, x_54);
+lean_ctor_set_uint8(x_59, 8, x_55);
+lean_ctor_set_uint8(x_59, 9, x_56);
+x_60 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_60, 0, x_59);
+lean_ctor_set(x_60, 1, x_45);
+lean_ctor_set(x_60, 2, x_46);
+lean_ctor_set(x_60, 3, x_47);
+x_61 = l_Lean_Meta_expandCoe___closed__1;
+x_62 = l_Lean_Meta_expandCoe___closed__2;
+x_63 = l_Lean_Meta_transform___at_Lean_Meta_expandCoe___spec__1(x_1, x_61, x_62, x_60, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_63) == 0)
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
-x_63 = lean_ctor_get(x_61, 1);
-lean_inc(x_63);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- lean_ctor_release(x_61, 1);
- x_64 = x_61;
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_64 = lean_ctor_get(x_63, 0);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_63, 1);
+lean_inc(x_65);
+if (lean_is_exclusive(x_63)) {
+ lean_ctor_release(x_63, 0);
+ lean_ctor_release(x_63, 1);
+ x_66 = x_63;
 } else {
- lean_dec_ref(x_61);
- x_64 = lean_box(0);
+ lean_dec_ref(x_63);
+ x_66 = lean_box(0);
 }
-if (lean_is_scalar(x_64)) {
- x_65 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_66)) {
+ x_67 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_65 = x_64;
+ x_67 = x_66;
 }
-lean_ctor_set(x_65, 0, x_62);
-lean_ctor_set(x_65, 1, x_63);
-return x_65;
+lean_ctor_set(x_67, 0, x_64);
+lean_ctor_set(x_67, 1, x_65);
+return x_67;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_66 = lean_ctor_get(x_61, 0);
-lean_inc(x_66);
-x_67 = lean_ctor_get(x_61, 1);
-lean_inc(x_67);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- lean_ctor_release(x_61, 1);
- x_68 = x_61;
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_68 = lean_ctor_get(x_63, 0);
+lean_inc(x_68);
+x_69 = lean_ctor_get(x_63, 1);
+lean_inc(x_69);
+if (lean_is_exclusive(x_63)) {
+ lean_ctor_release(x_63, 0);
+ lean_ctor_release(x_63, 1);
+ x_70 = x_63;
 } else {
- lean_dec_ref(x_61);
- x_68 = lean_box(0);
+ lean_dec_ref(x_63);
+ x_70 = lean_box(0);
 }
-if (lean_is_scalar(x_68)) {
- x_69 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_70)) {
+ x_71 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_69 = x_68;
+ x_71 = x_70;
 }
-lean_ctor_set(x_69, 0, x_66);
-lean_ctor_set(x_69, 1, x_67);
-return x_69;
+lean_ctor_set(x_71, 0, x_68);
+lean_ctor_set(x_71, 1, x_69);
+return x_71;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/DiscrTree.c b/stage0/stdlib/Lean/Meta/DiscrTree.c
index bd29f660b3..81cd195330 100644
--- a/stage0/stdlib/Lean/Meta/DiscrTree.c
+++ b/stage0/stdlib/Lean/Meta/DiscrTree.c
@@ -4825,7 +4825,7 @@ return x_22;
 }
 else
 {
-uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; 
+uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; uint8_t x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; 
 x_23 = lean_ctor_get_uint8(x_10, 0);
 x_24 = lean_ctor_get_uint8(x_10, 1);
 x_25 = lean_ctor_get_uint8(x_10, 2);
@@ -4834,166 +4834,170 @@ x_27 = lean_ctor_get_uint8(x_10, 4);
 x_28 = lean_ctor_get_uint8(x_10, 6);
 x_29 = lean_ctor_get_uint8(x_10, 7);
 x_30 = lean_ctor_get_uint8(x_10, 8);
+x_31 = lean_ctor_get_uint8(x_10, 9);
 lean_dec(x_10);
-x_31 = 2;
-x_32 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_32, 0, x_23);
-lean_ctor_set_uint8(x_32, 1, x_24);
-lean_ctor_set_uint8(x_32, 2, x_25);
-lean_ctor_set_uint8(x_32, 3, x_26);
-lean_ctor_set_uint8(x_32, 4, x_27);
-lean_ctor_set_uint8(x_32, 5, x_31);
-lean_ctor_set_uint8(x_32, 6, x_28);
-lean_ctor_set_uint8(x_32, 7, x_29);
-lean_ctor_set_uint8(x_32, 8, x_30);
-lean_ctor_set(x_2, 0, x_32);
-x_33 = 1;
-x_34 = l_Lean_Meta_DiscrTree_mkPathAux(x_33, x_8, x_7, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_34) == 0)
+x_32 = 2;
+x_33 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_33, 0, x_23);
+lean_ctor_set_uint8(x_33, 1, x_24);
+lean_ctor_set_uint8(x_33, 2, x_25);
+lean_ctor_set_uint8(x_33, 3, x_26);
+lean_ctor_set_uint8(x_33, 4, x_27);
+lean_ctor_set_uint8(x_33, 5, x_32);
+lean_ctor_set_uint8(x_33, 6, x_28);
+lean_ctor_set_uint8(x_33, 7, x_29);
+lean_ctor_set_uint8(x_33, 8, x_30);
+lean_ctor_set_uint8(x_33, 9, x_31);
+lean_ctor_set(x_2, 0, x_33);
+x_34 = 1;
+x_35 = l_Lean_Meta_DiscrTree_mkPathAux(x_34, x_8, x_7, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_35) == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_35 = lean_ctor_get(x_34, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_34, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_36 = lean_ctor_get(x_35, 0);
 lean_inc(x_36);
-if (lean_is_exclusive(x_34)) {
- lean_ctor_release(x_34, 0);
- lean_ctor_release(x_34, 1);
- x_37 = x_34;
+x_37 = lean_ctor_get(x_35, 1);
+lean_inc(x_37);
+if (lean_is_exclusive(x_35)) {
+ lean_ctor_release(x_35, 0);
+ lean_ctor_release(x_35, 1);
+ x_38 = x_35;
 } else {
- lean_dec_ref(x_34);
- x_37 = lean_box(0);
+ lean_dec_ref(x_35);
+ x_38 = lean_box(0);
 }
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_38)) {
+ x_39 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_38 = x_37;
+ x_39 = x_38;
 }
-lean_ctor_set(x_38, 0, x_35);
-lean_ctor_set(x_38, 1, x_36);
-return x_38;
+lean_ctor_set(x_39, 0, x_36);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_39 = lean_ctor_get(x_34, 0);
-lean_inc(x_39);
-x_40 = lean_ctor_get(x_34, 1);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_40 = lean_ctor_get(x_35, 0);
 lean_inc(x_40);
-if (lean_is_exclusive(x_34)) {
- lean_ctor_release(x_34, 0);
- lean_ctor_release(x_34, 1);
- x_41 = x_34;
+x_41 = lean_ctor_get(x_35, 1);
+lean_inc(x_41);
+if (lean_is_exclusive(x_35)) {
+ lean_ctor_release(x_35, 0);
+ lean_ctor_release(x_35, 1);
+ x_42 = x_35;
 } else {
- lean_dec_ref(x_34);
- x_41 = lean_box(0);
+ lean_dec_ref(x_35);
+ x_42 = lean_box(0);
 }
-if (lean_is_scalar(x_41)) {
- x_42 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_42)) {
+ x_43 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_42 = x_41;
+ x_43 = x_42;
 }
-lean_ctor_set(x_42, 0, x_39);
-lean_ctor_set(x_42, 1, x_40);
-return x_42;
+lean_ctor_set(x_43, 0, x_40);
+lean_ctor_set(x_43, 1, x_41);
+return x_43;
 }
 }
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; lean_object* x_60; 
-x_43 = lean_ctor_get(x_2, 0);
-x_44 = lean_ctor_get(x_2, 1);
-x_45 = lean_ctor_get(x_2, 2);
-x_46 = lean_ctor_get(x_2, 3);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; 
+x_44 = lean_ctor_get(x_2, 0);
+x_45 = lean_ctor_get(x_2, 1);
+x_46 = lean_ctor_get(x_2, 2);
+x_47 = lean_ctor_get(x_2, 3);
+lean_inc(x_47);
 lean_inc(x_46);
 lean_inc(x_45);
 lean_inc(x_44);
-lean_inc(x_43);
 lean_dec(x_2);
-x_47 = lean_ctor_get_uint8(x_43, 0);
-x_48 = lean_ctor_get_uint8(x_43, 1);
-x_49 = lean_ctor_get_uint8(x_43, 2);
-x_50 = lean_ctor_get_uint8(x_43, 3);
-x_51 = lean_ctor_get_uint8(x_43, 4);
-x_52 = lean_ctor_get_uint8(x_43, 6);
-x_53 = lean_ctor_get_uint8(x_43, 7);
-x_54 = lean_ctor_get_uint8(x_43, 8);
-if (lean_is_exclusive(x_43)) {
- x_55 = x_43;
+x_48 = lean_ctor_get_uint8(x_44, 0);
+x_49 = lean_ctor_get_uint8(x_44, 1);
+x_50 = lean_ctor_get_uint8(x_44, 2);
+x_51 = lean_ctor_get_uint8(x_44, 3);
+x_52 = lean_ctor_get_uint8(x_44, 4);
+x_53 = lean_ctor_get_uint8(x_44, 6);
+x_54 = lean_ctor_get_uint8(x_44, 7);
+x_55 = lean_ctor_get_uint8(x_44, 8);
+x_56 = lean_ctor_get_uint8(x_44, 9);
+if (lean_is_exclusive(x_44)) {
+ x_57 = x_44;
 } else {
- lean_dec_ref(x_43);
- x_55 = lean_box(0);
+ lean_dec_ref(x_44);
+ x_57 = lean_box(0);
 }
-x_56 = 2;
-if (lean_is_scalar(x_55)) {
- x_57 = lean_alloc_ctor(0, 0, 9);
+x_58 = 2;
+if (lean_is_scalar(x_57)) {
+ x_59 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_57 = x_55;
+ x_59 = x_57;
 }
-lean_ctor_set_uint8(x_57, 0, x_47);
-lean_ctor_set_uint8(x_57, 1, x_48);
-lean_ctor_set_uint8(x_57, 2, x_49);
-lean_ctor_set_uint8(x_57, 3, x_50);
-lean_ctor_set_uint8(x_57, 4, x_51);
-lean_ctor_set_uint8(x_57, 5, x_56);
-lean_ctor_set_uint8(x_57, 6, x_52);
-lean_ctor_set_uint8(x_57, 7, x_53);
-lean_ctor_set_uint8(x_57, 8, x_54);
-x_58 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set(x_58, 1, x_44);
-lean_ctor_set(x_58, 2, x_45);
-lean_ctor_set(x_58, 3, x_46);
-x_59 = 1;
-x_60 = l_Lean_Meta_DiscrTree_mkPathAux(x_59, x_8, x_7, x_58, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_60) == 0)
+lean_ctor_set_uint8(x_59, 0, x_48);
+lean_ctor_set_uint8(x_59, 1, x_49);
+lean_ctor_set_uint8(x_59, 2, x_50);
+lean_ctor_set_uint8(x_59, 3, x_51);
+lean_ctor_set_uint8(x_59, 4, x_52);
+lean_ctor_set_uint8(x_59, 5, x_58);
+lean_ctor_set_uint8(x_59, 6, x_53);
+lean_ctor_set_uint8(x_59, 7, x_54);
+lean_ctor_set_uint8(x_59, 8, x_55);
+lean_ctor_set_uint8(x_59, 9, x_56);
+x_60 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_60, 0, x_59);
+lean_ctor_set(x_60, 1, x_45);
+lean_ctor_set(x_60, 2, x_46);
+lean_ctor_set(x_60, 3, x_47);
+x_61 = 1;
+x_62 = l_Lean_Meta_DiscrTree_mkPathAux(x_61, x_8, x_7, x_60, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_62) == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = lean_ctor_get(x_60, 0);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_60, 1);
-lean_inc(x_62);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- lean_ctor_release(x_60, 1);
- x_63 = x_60;
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_63 = lean_ctor_get(x_62, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_62, 1);
+lean_inc(x_64);
+if (lean_is_exclusive(x_62)) {
+ lean_ctor_release(x_62, 0);
+ lean_ctor_release(x_62, 1);
+ x_65 = x_62;
 } else {
- lean_dec_ref(x_60);
- x_63 = lean_box(0);
+ lean_dec_ref(x_62);
+ x_65 = lean_box(0);
 }
-if (lean_is_scalar(x_63)) {
- x_64 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_65)) {
+ x_66 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_64 = x_63;
+ x_66 = x_65;
 }
-lean_ctor_set(x_64, 0, x_61);
-lean_ctor_set(x_64, 1, x_62);
-return x_64;
+lean_ctor_set(x_66, 0, x_63);
+lean_ctor_set(x_66, 1, x_64);
+return x_66;
 }
 else
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_65 = lean_ctor_get(x_60, 0);
-lean_inc(x_65);
-x_66 = lean_ctor_get(x_60, 1);
-lean_inc(x_66);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- lean_ctor_release(x_60, 1);
- x_67 = x_60;
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+x_67 = lean_ctor_get(x_62, 0);
+lean_inc(x_67);
+x_68 = lean_ctor_get(x_62, 1);
+lean_inc(x_68);
+if (lean_is_exclusive(x_62)) {
+ lean_ctor_release(x_62, 0);
+ lean_ctor_release(x_62, 1);
+ x_69 = x_62;
 } else {
- lean_dec_ref(x_60);
- x_67 = lean_box(0);
+ lean_dec_ref(x_62);
+ x_69 = lean_box(0);
 }
-if (lean_is_scalar(x_67)) {
- x_68 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_69)) {
+ x_70 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_68 = x_67;
+ x_70 = x_69;
 }
-lean_ctor_set(x_68, 0, x_65);
-lean_ctor_set(x_68, 1, x_66);
-return x_68;
+lean_ctor_set(x_70, 0, x_67);
+lean_ctor_set(x_70, 1, x_68);
+return x_70;
 }
 }
 }
@@ -15251,7 +15255,7 @@ return x_169;
 }
 else
 {
-uint8_t x_170; uint8_t x_171; uint8_t x_172; uint8_t x_173; uint8_t x_174; uint8_t x_175; uint8_t x_176; uint8_t x_177; uint8_t x_178; lean_object* x_179; uint8_t x_180; lean_object* x_181; 
+uint8_t x_170; uint8_t x_171; uint8_t x_172; uint8_t x_173; uint8_t x_174; uint8_t x_175; uint8_t x_176; uint8_t x_177; uint8_t x_178; uint8_t x_179; lean_object* x_180; uint8_t x_181; lean_object* x_182; 
 x_170 = lean_ctor_get_uint8(x_10, 0);
 x_171 = lean_ctor_get_uint8(x_10, 1);
 x_172 = lean_ctor_get_uint8(x_10, 2);
@@ -15260,521 +15264,523 @@ x_174 = lean_ctor_get_uint8(x_10, 4);
 x_175 = lean_ctor_get_uint8(x_10, 6);
 x_176 = lean_ctor_get_uint8(x_10, 7);
 x_177 = lean_ctor_get_uint8(x_10, 8);
+x_178 = lean_ctor_get_uint8(x_10, 9);
 lean_dec(x_10);
-x_178 = 2;
-x_179 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_179, 0, x_170);
-lean_ctor_set_uint8(x_179, 1, x_171);
-lean_ctor_set_uint8(x_179, 2, x_172);
-lean_ctor_set_uint8(x_179, 3, x_173);
-lean_ctor_set_uint8(x_179, 4, x_174);
-lean_ctor_set_uint8(x_179, 5, x_178);
-lean_ctor_set_uint8(x_179, 6, x_175);
-lean_ctor_set_uint8(x_179, 7, x_176);
-lean_ctor_set_uint8(x_179, 8, x_177);
-lean_ctor_set(x_3, 0, x_179);
-x_180 = 1;
+x_179 = 2;
+x_180 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_180, 0, x_170);
+lean_ctor_set_uint8(x_180, 1, x_171);
+lean_ctor_set_uint8(x_180, 2, x_172);
+lean_ctor_set_uint8(x_180, 3, x_173);
+lean_ctor_set_uint8(x_180, 4, x_174);
+lean_ctor_set_uint8(x_180, 5, x_179);
+lean_ctor_set_uint8(x_180, 6, x_175);
+lean_ctor_set_uint8(x_180, 7, x_176);
+lean_ctor_set_uint8(x_180, 8, x_177);
+lean_ctor_set_uint8(x_180, 9, x_178);
+lean_ctor_set(x_3, 0, x_180);
+x_181 = 1;
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_181 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_180, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_181) == 0)
+x_182 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_181, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_182) == 0)
 {
-lean_object* x_182; lean_object* x_183; 
-x_182 = lean_ctor_get(x_181, 0);
-lean_inc(x_182);
+lean_object* x_183; lean_object* x_184; 
 x_183 = lean_ctor_get(x_182, 0);
 lean_inc(x_183);
-switch (lean_obj_tag(x_183)) {
+x_184 = lean_ctor_get(x_183, 0);
+lean_inc(x_184);
+switch (lean_obj_tag(x_184)) {
 case 0:
 {
-lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; 
-x_184 = lean_ctor_get(x_181, 1);
-lean_inc(x_184);
-if (lean_is_exclusive(x_181)) {
- lean_ctor_release(x_181, 0);
- lean_ctor_release(x_181, 1);
- x_185 = x_181;
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; 
+x_185 = lean_ctor_get(x_182, 1);
+lean_inc(x_185);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_186 = x_182;
 } else {
- lean_dec_ref(x_181);
- x_185 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_186 = lean_box(0);
 }
-x_186 = lean_ctor_get(x_182, 1);
-lean_inc(x_186);
-lean_dec(x_182);
-x_187 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__1___rarg(x_1, x_183);
+x_187 = lean_ctor_get(x_183, 1);
+lean_inc(x_187);
 lean_dec(x_183);
-if (lean_obj_tag(x_187) == 0)
+x_188 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__1___rarg(x_1, x_184);
+lean_dec(x_184);
+if (lean_obj_tag(x_188) == 0)
 {
-lean_object* x_188; 
-lean_dec(x_186);
+lean_object* x_189; 
+lean_dec(x_187);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_185)) {
- x_188 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_186)) {
+ x_189 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_188 = x_185;
+ x_189 = x_186;
 }
-lean_ctor_set(x_188, 0, x_8);
-lean_ctor_set(x_188, 1, x_184);
-return x_188;
+lean_ctor_set(x_189, 0, x_8);
+lean_ctor_set(x_189, 1, x_185);
+return x_189;
 }
 else
 {
-lean_object* x_189; lean_object* x_190; 
-lean_dec(x_185);
-x_189 = lean_ctor_get(x_187, 0);
-lean_inc(x_189);
-lean_dec(x_187);
-x_190 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_186, x_189, x_8, x_3, x_4, x_5, x_6, x_184);
-if (lean_obj_tag(x_190) == 0)
+lean_object* x_190; lean_object* x_191; 
+lean_dec(x_186);
+x_190 = lean_ctor_get(x_188, 0);
+lean_inc(x_190);
+lean_dec(x_188);
+x_191 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_187, x_190, x_8, x_3, x_4, x_5, x_6, x_185);
+if (lean_obj_tag(x_191) == 0)
 {
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; 
-x_191 = lean_ctor_get(x_190, 0);
-lean_inc(x_191);
-x_192 = lean_ctor_get(x_190, 1);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; 
+x_192 = lean_ctor_get(x_191, 0);
 lean_inc(x_192);
-if (lean_is_exclusive(x_190)) {
- lean_ctor_release(x_190, 0);
- lean_ctor_release(x_190, 1);
- x_193 = x_190;
+x_193 = lean_ctor_get(x_191, 1);
+lean_inc(x_193);
+if (lean_is_exclusive(x_191)) {
+ lean_ctor_release(x_191, 0);
+ lean_ctor_release(x_191, 1);
+ x_194 = x_191;
 } else {
- lean_dec_ref(x_190);
- x_193 = lean_box(0);
+ lean_dec_ref(x_191);
+ x_194 = lean_box(0);
 }
-if (lean_is_scalar(x_193)) {
- x_194 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_194)) {
+ x_195 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_194 = x_193;
+ x_195 = x_194;
 }
-lean_ctor_set(x_194, 0, x_191);
-lean_ctor_set(x_194, 1, x_192);
-return x_194;
+lean_ctor_set(x_195, 0, x_192);
+lean_ctor_set(x_195, 1, x_193);
+return x_195;
 }
 else
 {
-lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; 
-x_195 = lean_ctor_get(x_190, 0);
-lean_inc(x_195);
-x_196 = lean_ctor_get(x_190, 1);
+lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; 
+x_196 = lean_ctor_get(x_191, 0);
 lean_inc(x_196);
-if (lean_is_exclusive(x_190)) {
- lean_ctor_release(x_190, 0);
- lean_ctor_release(x_190, 1);
- x_197 = x_190;
+x_197 = lean_ctor_get(x_191, 1);
+lean_inc(x_197);
+if (lean_is_exclusive(x_191)) {
+ lean_ctor_release(x_191, 0);
+ lean_ctor_release(x_191, 1);
+ x_198 = x_191;
 } else {
- lean_dec_ref(x_190);
- x_197 = lean_box(0);
+ lean_dec_ref(x_191);
+ x_198 = lean_box(0);
 }
-if (lean_is_scalar(x_197)) {
- x_198 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_198 = x_197;
+ x_199 = x_198;
 }
-lean_ctor_set(x_198, 0, x_195);
-lean_ctor_set(x_198, 1, x_196);
-return x_198;
+lean_ctor_set(x_199, 0, x_196);
+lean_ctor_set(x_199, 1, x_197);
+return x_199;
 }
 }
 }
 case 1:
 {
-lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; 
-x_199 = lean_ctor_get(x_181, 1);
-lean_inc(x_199);
-if (lean_is_exclusive(x_181)) {
- lean_ctor_release(x_181, 0);
- lean_ctor_release(x_181, 1);
- x_200 = x_181;
+lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; 
+x_200 = lean_ctor_get(x_182, 1);
+lean_inc(x_200);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_201 = x_182;
 } else {
- lean_dec_ref(x_181);
- x_200 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_201 = lean_box(0);
 }
-x_201 = lean_ctor_get(x_182, 1);
-lean_inc(x_201);
-lean_dec(x_182);
-x_202 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__4___rarg(x_1, x_183);
+x_202 = lean_ctor_get(x_183, 1);
+lean_inc(x_202);
 lean_dec(x_183);
-if (lean_obj_tag(x_202) == 0)
+x_203 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__4___rarg(x_1, x_184);
+lean_dec(x_184);
+if (lean_obj_tag(x_203) == 0)
 {
-lean_object* x_203; 
-lean_dec(x_201);
+lean_object* x_204; 
+lean_dec(x_202);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_200)) {
- x_203 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_201)) {
+ x_204 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_203 = x_200;
+ x_204 = x_201;
 }
-lean_ctor_set(x_203, 0, x_8);
-lean_ctor_set(x_203, 1, x_199);
-return x_203;
+lean_ctor_set(x_204, 0, x_8);
+lean_ctor_set(x_204, 1, x_200);
+return x_204;
 }
 else
 {
-lean_object* x_204; lean_object* x_205; 
-lean_dec(x_200);
-x_204 = lean_ctor_get(x_202, 0);
-lean_inc(x_204);
-lean_dec(x_202);
-x_205 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_201, x_204, x_8, x_3, x_4, x_5, x_6, x_199);
-if (lean_obj_tag(x_205) == 0)
+lean_object* x_205; lean_object* x_206; 
+lean_dec(x_201);
+x_205 = lean_ctor_get(x_203, 0);
+lean_inc(x_205);
+lean_dec(x_203);
+x_206 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_202, x_205, x_8, x_3, x_4, x_5, x_6, x_200);
+if (lean_obj_tag(x_206) == 0)
 {
-lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; 
-x_206 = lean_ctor_get(x_205, 0);
-lean_inc(x_206);
-x_207 = lean_ctor_get(x_205, 1);
+lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; 
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-if (lean_is_exclusive(x_205)) {
- lean_ctor_release(x_205, 0);
- lean_ctor_release(x_205, 1);
- x_208 = x_205;
+x_208 = lean_ctor_get(x_206, 1);
+lean_inc(x_208);
+if (lean_is_exclusive(x_206)) {
+ lean_ctor_release(x_206, 0);
+ lean_ctor_release(x_206, 1);
+ x_209 = x_206;
 } else {
- lean_dec_ref(x_205);
- x_208 = lean_box(0);
+ lean_dec_ref(x_206);
+ x_209 = lean_box(0);
 }
-if (lean_is_scalar(x_208)) {
- x_209 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_209)) {
+ x_210 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_209 = x_208;
+ x_210 = x_209;
 }
-lean_ctor_set(x_209, 0, x_206);
-lean_ctor_set(x_209, 1, x_207);
-return x_209;
+lean_ctor_set(x_210, 0, x_207);
+lean_ctor_set(x_210, 1, x_208);
+return x_210;
 }
 else
 {
-lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; 
-x_210 = lean_ctor_get(x_205, 0);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_205, 1);
+lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; 
+x_211 = lean_ctor_get(x_206, 0);
 lean_inc(x_211);
-if (lean_is_exclusive(x_205)) {
- lean_ctor_release(x_205, 0);
- lean_ctor_release(x_205, 1);
- x_212 = x_205;
+x_212 = lean_ctor_get(x_206, 1);
+lean_inc(x_212);
+if (lean_is_exclusive(x_206)) {
+ lean_ctor_release(x_206, 0);
+ lean_ctor_release(x_206, 1);
+ x_213 = x_206;
 } else {
- lean_dec_ref(x_205);
- x_212 = lean_box(0);
+ lean_dec_ref(x_206);
+ x_213 = lean_box(0);
 }
-if (lean_is_scalar(x_212)) {
- x_213 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_213)) {
+ x_214 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_213 = x_212;
+ x_214 = x_213;
 }
-lean_ctor_set(x_213, 0, x_210);
-lean_ctor_set(x_213, 1, x_211);
-return x_213;
+lean_ctor_set(x_214, 0, x_211);
+lean_ctor_set(x_214, 1, x_212);
+return x_214;
 }
 }
 }
 case 2:
 {
-lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; 
-x_214 = lean_ctor_get(x_181, 1);
-lean_inc(x_214);
-if (lean_is_exclusive(x_181)) {
- lean_ctor_release(x_181, 0);
- lean_ctor_release(x_181, 1);
- x_215 = x_181;
+lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; 
+x_215 = lean_ctor_get(x_182, 1);
+lean_inc(x_215);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_216 = x_182;
 } else {
- lean_dec_ref(x_181);
- x_215 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_216 = lean_box(0);
 }
-x_216 = lean_ctor_get(x_182, 1);
-lean_inc(x_216);
-lean_dec(x_182);
-x_217 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__7___rarg(x_1, x_183);
+x_217 = lean_ctor_get(x_183, 1);
+lean_inc(x_217);
 lean_dec(x_183);
-if (lean_obj_tag(x_217) == 0)
+x_218 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__7___rarg(x_1, x_184);
+lean_dec(x_184);
+if (lean_obj_tag(x_218) == 0)
 {
-lean_object* x_218; 
-lean_dec(x_216);
+lean_object* x_219; 
+lean_dec(x_217);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_215)) {
- x_218 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_216)) {
+ x_219 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_218 = x_215;
+ x_219 = x_216;
 }
-lean_ctor_set(x_218, 0, x_8);
-lean_ctor_set(x_218, 1, x_214);
-return x_218;
+lean_ctor_set(x_219, 0, x_8);
+lean_ctor_set(x_219, 1, x_215);
+return x_219;
 }
 else
 {
-lean_object* x_219; lean_object* x_220; 
-lean_dec(x_215);
-x_219 = lean_ctor_get(x_217, 0);
-lean_inc(x_219);
-lean_dec(x_217);
-x_220 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_216, x_219, x_8, x_3, x_4, x_5, x_6, x_214);
-if (lean_obj_tag(x_220) == 0)
+lean_object* x_220; lean_object* x_221; 
+lean_dec(x_216);
+x_220 = lean_ctor_get(x_218, 0);
+lean_inc(x_220);
+lean_dec(x_218);
+x_221 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_217, x_220, x_8, x_3, x_4, x_5, x_6, x_215);
+if (lean_obj_tag(x_221) == 0)
 {
-lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_220, 0);
-lean_inc(x_221);
-x_222 = lean_ctor_get(x_220, 1);
+lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; 
+x_222 = lean_ctor_get(x_221, 0);
 lean_inc(x_222);
-if (lean_is_exclusive(x_220)) {
- lean_ctor_release(x_220, 0);
- lean_ctor_release(x_220, 1);
- x_223 = x_220;
+x_223 = lean_ctor_get(x_221, 1);
+lean_inc(x_223);
+if (lean_is_exclusive(x_221)) {
+ lean_ctor_release(x_221, 0);
+ lean_ctor_release(x_221, 1);
+ x_224 = x_221;
 } else {
- lean_dec_ref(x_220);
- x_223 = lean_box(0);
+ lean_dec_ref(x_221);
+ x_224 = lean_box(0);
 }
-if (lean_is_scalar(x_223)) {
- x_224 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_224)) {
+ x_225 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_224 = x_223;
+ x_225 = x_224;
 }
-lean_ctor_set(x_224, 0, x_221);
-lean_ctor_set(x_224, 1, x_222);
-return x_224;
+lean_ctor_set(x_225, 0, x_222);
+lean_ctor_set(x_225, 1, x_223);
+return x_225;
 }
 else
 {
-lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; 
-x_225 = lean_ctor_get(x_220, 0);
-lean_inc(x_225);
-x_226 = lean_ctor_get(x_220, 1);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; 
+x_226 = lean_ctor_get(x_221, 0);
 lean_inc(x_226);
-if (lean_is_exclusive(x_220)) {
- lean_ctor_release(x_220, 0);
- lean_ctor_release(x_220, 1);
- x_227 = x_220;
+x_227 = lean_ctor_get(x_221, 1);
+lean_inc(x_227);
+if (lean_is_exclusive(x_221)) {
+ lean_ctor_release(x_221, 0);
+ lean_ctor_release(x_221, 1);
+ x_228 = x_221;
 } else {
- lean_dec_ref(x_220);
- x_227 = lean_box(0);
+ lean_dec_ref(x_221);
+ x_228 = lean_box(0);
 }
-if (lean_is_scalar(x_227)) {
- x_228 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_228)) {
+ x_229 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_228 = x_227;
+ x_229 = x_228;
 }
-lean_ctor_set(x_228, 0, x_225);
-lean_ctor_set(x_228, 1, x_226);
-return x_228;
+lean_ctor_set(x_229, 0, x_226);
+lean_ctor_set(x_229, 1, x_227);
+return x_229;
 }
 }
 }
 case 3:
 {
-lean_object* x_229; lean_object* x_230; lean_object* x_231; 
-lean_dec(x_182);
+lean_object* x_230; lean_object* x_231; lean_object* x_232; 
+lean_dec(x_183);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_229 = lean_ctor_get(x_181, 1);
-lean_inc(x_229);
-if (lean_is_exclusive(x_181)) {
- lean_ctor_release(x_181, 0);
- lean_ctor_release(x_181, 1);
- x_230 = x_181;
+x_230 = lean_ctor_get(x_182, 1);
+lean_inc(x_230);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_231 = x_182;
 } else {
- lean_dec_ref(x_181);
- x_230 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_231 = lean_box(0);
 }
-if (lean_is_scalar(x_230)) {
- x_231 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_231)) {
+ x_232 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_231 = x_230;
+ x_232 = x_231;
 }
-lean_ctor_set(x_231, 0, x_8);
-lean_ctor_set(x_231, 1, x_229);
-return x_231;
+lean_ctor_set(x_232, 0, x_8);
+lean_ctor_set(x_232, 1, x_230);
+return x_232;
 }
 case 4:
 {
-lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; 
-x_232 = lean_ctor_get(x_181, 1);
-lean_inc(x_232);
-if (lean_is_exclusive(x_181)) {
- lean_ctor_release(x_181, 0);
- lean_ctor_release(x_181, 1);
- x_233 = x_181;
+lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; 
+x_233 = lean_ctor_get(x_182, 1);
+lean_inc(x_233);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_234 = x_182;
 } else {
- lean_dec_ref(x_181);
- x_233 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_234 = lean_box(0);
 }
-x_234 = lean_ctor_get(x_182, 1);
-lean_inc(x_234);
-lean_dec(x_182);
-x_235 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__10___rarg(x_1, x_183);
-if (lean_obj_tag(x_235) == 0)
+x_235 = lean_ctor_get(x_183, 1);
+lean_inc(x_235);
+lean_dec(x_183);
+x_236 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__10___rarg(x_1, x_184);
+if (lean_obj_tag(x_236) == 0)
 {
-lean_object* x_236; 
-lean_dec(x_234);
+lean_object* x_237; 
+lean_dec(x_235);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_233)) {
- x_236 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_234)) {
+ x_237 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_236 = x_233;
+ x_237 = x_234;
 }
-lean_ctor_set(x_236, 0, x_8);
-lean_ctor_set(x_236, 1, x_232);
-return x_236;
+lean_ctor_set(x_237, 0, x_8);
+lean_ctor_set(x_237, 1, x_233);
+return x_237;
 }
 else
 {
-lean_object* x_237; lean_object* x_238; 
-lean_dec(x_233);
-x_237 = lean_ctor_get(x_235, 0);
-lean_inc(x_237);
-lean_dec(x_235);
-x_238 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_234, x_237, x_8, x_3, x_4, x_5, x_6, x_232);
-if (lean_obj_tag(x_238) == 0)
+lean_object* x_238; lean_object* x_239; 
+lean_dec(x_234);
+x_238 = lean_ctor_get(x_236, 0);
+lean_inc(x_238);
+lean_dec(x_236);
+x_239 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_235, x_238, x_8, x_3, x_4, x_5, x_6, x_233);
+if (lean_obj_tag(x_239) == 0)
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; 
-x_239 = lean_ctor_get(x_238, 0);
-lean_inc(x_239);
-x_240 = lean_ctor_get(x_238, 1);
+lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; 
+x_240 = lean_ctor_get(x_239, 0);
 lean_inc(x_240);
-if (lean_is_exclusive(x_238)) {
- lean_ctor_release(x_238, 0);
- lean_ctor_release(x_238, 1);
- x_241 = x_238;
+x_241 = lean_ctor_get(x_239, 1);
+lean_inc(x_241);
+if (lean_is_exclusive(x_239)) {
+ lean_ctor_release(x_239, 0);
+ lean_ctor_release(x_239, 1);
+ x_242 = x_239;
 } else {
- lean_dec_ref(x_238);
- x_241 = lean_box(0);
+ lean_dec_ref(x_239);
+ x_242 = lean_box(0);
 }
-if (lean_is_scalar(x_241)) {
- x_242 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_242)) {
+ x_243 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_242 = x_241;
+ x_243 = x_242;
 }
-lean_ctor_set(x_242, 0, x_239);
-lean_ctor_set(x_242, 1, x_240);
-return x_242;
+lean_ctor_set(x_243, 0, x_240);
+lean_ctor_set(x_243, 1, x_241);
+return x_243;
 }
 else
 {
-lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; 
-x_243 = lean_ctor_get(x_238, 0);
-lean_inc(x_243);
-x_244 = lean_ctor_get(x_238, 1);
+lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; 
+x_244 = lean_ctor_get(x_239, 0);
 lean_inc(x_244);
-if (lean_is_exclusive(x_238)) {
- lean_ctor_release(x_238, 0);
- lean_ctor_release(x_238, 1);
- x_245 = x_238;
+x_245 = lean_ctor_get(x_239, 1);
+lean_inc(x_245);
+if (lean_is_exclusive(x_239)) {
+ lean_ctor_release(x_239, 0);
+ lean_ctor_release(x_239, 1);
+ x_246 = x_239;
 } else {
- lean_dec_ref(x_238);
- x_245 = lean_box(0);
+ lean_dec_ref(x_239);
+ x_246 = lean_box(0);
 }
-if (lean_is_scalar(x_245)) {
- x_246 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_246)) {
+ x_247 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_246 = x_245;
+ x_247 = x_246;
 }
-lean_ctor_set(x_246, 0, x_243);
-lean_ctor_set(x_246, 1, x_244);
-return x_246;
+lean_ctor_set(x_247, 0, x_244);
+lean_ctor_set(x_247, 1, x_245);
+return x_247;
 }
 }
 }
 default: 
 {
-lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; 
-x_247 = lean_ctor_get(x_181, 1);
-lean_inc(x_247);
-if (lean_is_exclusive(x_181)) {
- lean_ctor_release(x_181, 0);
- lean_ctor_release(x_181, 1);
- x_248 = x_181;
+lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; 
+x_248 = lean_ctor_get(x_182, 1);
+lean_inc(x_248);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_249 = x_182;
 } else {
- lean_dec_ref(x_181);
- x_248 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_249 = lean_box(0);
 }
-x_249 = lean_ctor_get(x_182, 1);
-lean_inc(x_249);
-lean_dec(x_182);
-x_250 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__13___rarg(x_1, x_183);
-if (lean_obj_tag(x_250) == 0)
+x_250 = lean_ctor_get(x_183, 1);
+lean_inc(x_250);
+lean_dec(x_183);
+x_251 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__13___rarg(x_1, x_184);
+if (lean_obj_tag(x_251) == 0)
 {
-lean_object* x_251; 
-lean_dec(x_249);
+lean_object* x_252; 
+lean_dec(x_250);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_248)) {
- x_251 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_249)) {
+ x_252 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_251 = x_248;
+ x_252 = x_249;
 }
-lean_ctor_set(x_251, 0, x_8);
-lean_ctor_set(x_251, 1, x_247);
-return x_251;
+lean_ctor_set(x_252, 0, x_8);
+lean_ctor_set(x_252, 1, x_248);
+return x_252;
 }
 else
 {
-lean_object* x_252; lean_object* x_253; 
-lean_dec(x_248);
-x_252 = lean_ctor_get(x_250, 0);
-lean_inc(x_252);
-lean_dec(x_250);
-x_253 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_249, x_252, x_8, x_3, x_4, x_5, x_6, x_247);
-if (lean_obj_tag(x_253) == 0)
+lean_object* x_253; lean_object* x_254; 
+lean_dec(x_249);
+x_253 = lean_ctor_get(x_251, 0);
+lean_inc(x_253);
+lean_dec(x_251);
+x_254 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_250, x_253, x_8, x_3, x_4, x_5, x_6, x_248);
+if (lean_obj_tag(x_254) == 0)
 {
-lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; 
-x_254 = lean_ctor_get(x_253, 0);
-lean_inc(x_254);
-x_255 = lean_ctor_get(x_253, 1);
+lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; 
+x_255 = lean_ctor_get(x_254, 0);
 lean_inc(x_255);
-if (lean_is_exclusive(x_253)) {
- lean_ctor_release(x_253, 0);
- lean_ctor_release(x_253, 1);
- x_256 = x_253;
+x_256 = lean_ctor_get(x_254, 1);
+lean_inc(x_256);
+if (lean_is_exclusive(x_254)) {
+ lean_ctor_release(x_254, 0);
+ lean_ctor_release(x_254, 1);
+ x_257 = x_254;
 } else {
- lean_dec_ref(x_253);
- x_256 = lean_box(0);
+ lean_dec_ref(x_254);
+ x_257 = lean_box(0);
 }
-if (lean_is_scalar(x_256)) {
- x_257 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_257)) {
+ x_258 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_257 = x_256;
+ x_258 = x_257;
 }
-lean_ctor_set(x_257, 0, x_254);
-lean_ctor_set(x_257, 1, x_255);
-return x_257;
+lean_ctor_set(x_258, 0, x_255);
+lean_ctor_set(x_258, 1, x_256);
+return x_258;
 }
 else
 {
-lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; 
-x_258 = lean_ctor_get(x_253, 0);
-lean_inc(x_258);
-x_259 = lean_ctor_get(x_253, 1);
+lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; 
+x_259 = lean_ctor_get(x_254, 0);
 lean_inc(x_259);
-if (lean_is_exclusive(x_253)) {
- lean_ctor_release(x_253, 0);
- lean_ctor_release(x_253, 1);
- x_260 = x_253;
+x_260 = lean_ctor_get(x_254, 1);
+lean_inc(x_260);
+if (lean_is_exclusive(x_254)) {
+ lean_ctor_release(x_254, 0);
+ lean_ctor_release(x_254, 1);
+ x_261 = x_254;
 } else {
- lean_dec_ref(x_253);
- x_260 = lean_box(0);
+ lean_dec_ref(x_254);
+ x_261 = lean_box(0);
 }
-if (lean_is_scalar(x_260)) {
- x_261 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_261)) {
+ x_262 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_261 = x_260;
+ x_262 = x_261;
 }
-lean_ctor_set(x_261, 0, x_258);
-lean_ctor_set(x_261, 1, x_259);
-return x_261;
+lean_ctor_set(x_262, 0, x_259);
+lean_ctor_set(x_262, 1, x_260);
+return x_262;
 }
 }
 }
@@ -15782,584 +15788,586 @@ return x_261;
 }
 else
 {
-lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; 
+lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; 
 lean_dec(x_3);
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_262 = lean_ctor_get(x_181, 0);
-lean_inc(x_262);
-x_263 = lean_ctor_get(x_181, 1);
+x_263 = lean_ctor_get(x_182, 0);
 lean_inc(x_263);
-if (lean_is_exclusive(x_181)) {
- lean_ctor_release(x_181, 0);
- lean_ctor_release(x_181, 1);
- x_264 = x_181;
+x_264 = lean_ctor_get(x_182, 1);
+lean_inc(x_264);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_265 = x_182;
 } else {
- lean_dec_ref(x_181);
- x_264 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_265 = lean_box(0);
 }
-if (lean_is_scalar(x_264)) {
- x_265 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_265)) {
+ x_266 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_265 = x_264;
+ x_266 = x_265;
 }
-lean_ctor_set(x_265, 0, x_262);
-lean_ctor_set(x_265, 1, x_263);
-return x_265;
+lean_ctor_set(x_266, 0, x_263);
+lean_ctor_set(x_266, 1, x_264);
+return x_266;
 }
 }
 }
 else
 {
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; uint8_t x_271; uint8_t x_272; uint8_t x_273; uint8_t x_274; uint8_t x_275; uint8_t x_276; uint8_t x_277; lean_object* x_278; uint8_t x_279; lean_object* x_280; lean_object* x_281; uint8_t x_282; lean_object* x_283; 
-x_266 = lean_ctor_get(x_3, 0);
-x_267 = lean_ctor_get(x_3, 1);
-x_268 = lean_ctor_get(x_3, 2);
-x_269 = lean_ctor_get(x_3, 3);
+lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; uint8_t x_271; uint8_t x_272; uint8_t x_273; uint8_t x_274; uint8_t x_275; uint8_t x_276; uint8_t x_277; uint8_t x_278; uint8_t x_279; lean_object* x_280; uint8_t x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; 
+x_267 = lean_ctor_get(x_3, 0);
+x_268 = lean_ctor_get(x_3, 1);
+x_269 = lean_ctor_get(x_3, 2);
+x_270 = lean_ctor_get(x_3, 3);
+lean_inc(x_270);
 lean_inc(x_269);
 lean_inc(x_268);
 lean_inc(x_267);
-lean_inc(x_266);
 lean_dec(x_3);
-x_270 = lean_ctor_get_uint8(x_266, 0);
-x_271 = lean_ctor_get_uint8(x_266, 1);
-x_272 = lean_ctor_get_uint8(x_266, 2);
-x_273 = lean_ctor_get_uint8(x_266, 3);
-x_274 = lean_ctor_get_uint8(x_266, 4);
-x_275 = lean_ctor_get_uint8(x_266, 6);
-x_276 = lean_ctor_get_uint8(x_266, 7);
-x_277 = lean_ctor_get_uint8(x_266, 8);
-if (lean_is_exclusive(x_266)) {
- x_278 = x_266;
+x_271 = lean_ctor_get_uint8(x_267, 0);
+x_272 = lean_ctor_get_uint8(x_267, 1);
+x_273 = lean_ctor_get_uint8(x_267, 2);
+x_274 = lean_ctor_get_uint8(x_267, 3);
+x_275 = lean_ctor_get_uint8(x_267, 4);
+x_276 = lean_ctor_get_uint8(x_267, 6);
+x_277 = lean_ctor_get_uint8(x_267, 7);
+x_278 = lean_ctor_get_uint8(x_267, 8);
+x_279 = lean_ctor_get_uint8(x_267, 9);
+if (lean_is_exclusive(x_267)) {
+ x_280 = x_267;
 } else {
- lean_dec_ref(x_266);
- x_278 = lean_box(0);
+ lean_dec_ref(x_267);
+ x_280 = lean_box(0);
 }
-x_279 = 2;
-if (lean_is_scalar(x_278)) {
- x_280 = lean_alloc_ctor(0, 0, 9);
+x_281 = 2;
+if (lean_is_scalar(x_280)) {
+ x_282 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_280 = x_278;
+ x_282 = x_280;
 }
-lean_ctor_set_uint8(x_280, 0, x_270);
-lean_ctor_set_uint8(x_280, 1, x_271);
-lean_ctor_set_uint8(x_280, 2, x_272);
-lean_ctor_set_uint8(x_280, 3, x_273);
-lean_ctor_set_uint8(x_280, 4, x_274);
-lean_ctor_set_uint8(x_280, 5, x_279);
-lean_ctor_set_uint8(x_280, 6, x_275);
-lean_ctor_set_uint8(x_280, 7, x_276);
-lean_ctor_set_uint8(x_280, 8, x_277);
-x_281 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_281, 0, x_280);
-lean_ctor_set(x_281, 1, x_267);
-lean_ctor_set(x_281, 2, x_268);
-lean_ctor_set(x_281, 3, x_269);
-x_282 = 1;
+lean_ctor_set_uint8(x_282, 0, x_271);
+lean_ctor_set_uint8(x_282, 1, x_272);
+lean_ctor_set_uint8(x_282, 2, x_273);
+lean_ctor_set_uint8(x_282, 3, x_274);
+lean_ctor_set_uint8(x_282, 4, x_275);
+lean_ctor_set_uint8(x_282, 5, x_281);
+lean_ctor_set_uint8(x_282, 6, x_276);
+lean_ctor_set_uint8(x_282, 7, x_277);
+lean_ctor_set_uint8(x_282, 8, x_278);
+lean_ctor_set_uint8(x_282, 9, x_279);
+x_283 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_283, 0, x_282);
+lean_ctor_set(x_283, 1, x_268);
+lean_ctor_set(x_283, 2, x_269);
+lean_ctor_set(x_283, 3, x_270);
+x_284 = 1;
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_281);
-x_283 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_282, x_281, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_283) == 0)
+lean_inc(x_283);
+x_285 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_284, x_283, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_285) == 0)
 {
-lean_object* x_284; lean_object* x_285; 
-x_284 = lean_ctor_get(x_283, 0);
-lean_inc(x_284);
-x_285 = lean_ctor_get(x_284, 0);
-lean_inc(x_285);
-switch (lean_obj_tag(x_285)) {
+lean_object* x_286; lean_object* x_287; 
+x_286 = lean_ctor_get(x_285, 0);
+lean_inc(x_286);
+x_287 = lean_ctor_get(x_286, 0);
+lean_inc(x_287);
+switch (lean_obj_tag(x_287)) {
 case 0:
 {
-lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; 
-x_286 = lean_ctor_get(x_283, 1);
-lean_inc(x_286);
-if (lean_is_exclusive(x_283)) {
- lean_ctor_release(x_283, 0);
- lean_ctor_release(x_283, 1);
- x_287 = x_283;
-} else {
- lean_dec_ref(x_283);
- x_287 = lean_box(0);
-}
-x_288 = lean_ctor_get(x_284, 1);
+lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; 
+x_288 = lean_ctor_get(x_285, 1);
 lean_inc(x_288);
-lean_dec(x_284);
-x_289 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__1___rarg(x_1, x_285);
-lean_dec(x_285);
-if (lean_obj_tag(x_289) == 0)
+if (lean_is_exclusive(x_285)) {
+ lean_ctor_release(x_285, 0);
+ lean_ctor_release(x_285, 1);
+ x_289 = x_285;
+} else {
+ lean_dec_ref(x_285);
+ x_289 = lean_box(0);
+}
+x_290 = lean_ctor_get(x_286, 1);
+lean_inc(x_290);
+lean_dec(x_286);
+x_291 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__1___rarg(x_1, x_287);
+lean_dec(x_287);
+if (lean_obj_tag(x_291) == 0)
 {
-lean_object* x_290; 
-lean_dec(x_288);
-lean_dec(x_281);
+lean_object* x_292; 
+lean_dec(x_290);
+lean_dec(x_283);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_287)) {
- x_290 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_289)) {
+ x_292 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_290 = x_287;
+ x_292 = x_289;
 }
-lean_ctor_set(x_290, 0, x_8);
-lean_ctor_set(x_290, 1, x_286);
-return x_290;
+lean_ctor_set(x_292, 0, x_8);
+lean_ctor_set(x_292, 1, x_288);
+return x_292;
 }
 else
 {
-lean_object* x_291; lean_object* x_292; 
-lean_dec(x_287);
-x_291 = lean_ctor_get(x_289, 0);
-lean_inc(x_291);
+lean_object* x_293; lean_object* x_294; 
 lean_dec(x_289);
-x_292 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_288, x_291, x_8, x_281, x_4, x_5, x_6, x_286);
-if (lean_obj_tag(x_292) == 0)
-{
-lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; 
-x_293 = lean_ctor_get(x_292, 0);
+x_293 = lean_ctor_get(x_291, 0);
 lean_inc(x_293);
-x_294 = lean_ctor_get(x_292, 1);
-lean_inc(x_294);
-if (lean_is_exclusive(x_292)) {
- lean_ctor_release(x_292, 0);
- lean_ctor_release(x_292, 1);
- x_295 = x_292;
+lean_dec(x_291);
+x_294 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_290, x_293, x_8, x_283, x_4, x_5, x_6, x_288);
+if (lean_obj_tag(x_294) == 0)
+{
+lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; 
+x_295 = lean_ctor_get(x_294, 0);
+lean_inc(x_295);
+x_296 = lean_ctor_get(x_294, 1);
+lean_inc(x_296);
+if (lean_is_exclusive(x_294)) {
+ lean_ctor_release(x_294, 0);
+ lean_ctor_release(x_294, 1);
+ x_297 = x_294;
 } else {
- lean_dec_ref(x_292);
- x_295 = lean_box(0);
+ lean_dec_ref(x_294);
+ x_297 = lean_box(0);
 }
-if (lean_is_scalar(x_295)) {
- x_296 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_297)) {
+ x_298 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_296 = x_295;
+ x_298 = x_297;
 }
-lean_ctor_set(x_296, 0, x_293);
-lean_ctor_set(x_296, 1, x_294);
-return x_296;
+lean_ctor_set(x_298, 0, x_295);
+lean_ctor_set(x_298, 1, x_296);
+return x_298;
 }
 else
 {
-lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; 
-x_297 = lean_ctor_get(x_292, 0);
-lean_inc(x_297);
-x_298 = lean_ctor_get(x_292, 1);
-lean_inc(x_298);
-if (lean_is_exclusive(x_292)) {
- lean_ctor_release(x_292, 0);
- lean_ctor_release(x_292, 1);
- x_299 = x_292;
+lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; 
+x_299 = lean_ctor_get(x_294, 0);
+lean_inc(x_299);
+x_300 = lean_ctor_get(x_294, 1);
+lean_inc(x_300);
+if (lean_is_exclusive(x_294)) {
+ lean_ctor_release(x_294, 0);
+ lean_ctor_release(x_294, 1);
+ x_301 = x_294;
 } else {
- lean_dec_ref(x_292);
- x_299 = lean_box(0);
+ lean_dec_ref(x_294);
+ x_301 = lean_box(0);
 }
-if (lean_is_scalar(x_299)) {
- x_300 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_301)) {
+ x_302 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_300 = x_299;
+ x_302 = x_301;
 }
-lean_ctor_set(x_300, 0, x_297);
-lean_ctor_set(x_300, 1, x_298);
-return x_300;
+lean_ctor_set(x_302, 0, x_299);
+lean_ctor_set(x_302, 1, x_300);
+return x_302;
 }
 }
 }
 case 1:
 {
-lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; 
-x_301 = lean_ctor_get(x_283, 1);
-lean_inc(x_301);
-if (lean_is_exclusive(x_283)) {
- lean_ctor_release(x_283, 0);
- lean_ctor_release(x_283, 1);
- x_302 = x_283;
-} else {
- lean_dec_ref(x_283);
- x_302 = lean_box(0);
-}
-x_303 = lean_ctor_get(x_284, 1);
+lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; 
+x_303 = lean_ctor_get(x_285, 1);
 lean_inc(x_303);
-lean_dec(x_284);
-x_304 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__4___rarg(x_1, x_285);
-lean_dec(x_285);
-if (lean_obj_tag(x_304) == 0)
+if (lean_is_exclusive(x_285)) {
+ lean_ctor_release(x_285, 0);
+ lean_ctor_release(x_285, 1);
+ x_304 = x_285;
+} else {
+ lean_dec_ref(x_285);
+ x_304 = lean_box(0);
+}
+x_305 = lean_ctor_get(x_286, 1);
+lean_inc(x_305);
+lean_dec(x_286);
+x_306 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__4___rarg(x_1, x_287);
+lean_dec(x_287);
+if (lean_obj_tag(x_306) == 0)
 {
-lean_object* x_305; 
-lean_dec(x_303);
-lean_dec(x_281);
+lean_object* x_307; 
+lean_dec(x_305);
+lean_dec(x_283);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_302)) {
- x_305 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_304)) {
+ x_307 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_305 = x_302;
+ x_307 = x_304;
 }
-lean_ctor_set(x_305, 0, x_8);
-lean_ctor_set(x_305, 1, x_301);
-return x_305;
+lean_ctor_set(x_307, 0, x_8);
+lean_ctor_set(x_307, 1, x_303);
+return x_307;
 }
 else
 {
-lean_object* x_306; lean_object* x_307; 
-lean_dec(x_302);
-x_306 = lean_ctor_get(x_304, 0);
-lean_inc(x_306);
+lean_object* x_308; lean_object* x_309; 
 lean_dec(x_304);
-x_307 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_303, x_306, x_8, x_281, x_4, x_5, x_6, x_301);
-if (lean_obj_tag(x_307) == 0)
-{
-lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; 
-x_308 = lean_ctor_get(x_307, 0);
+x_308 = lean_ctor_get(x_306, 0);
 lean_inc(x_308);
-x_309 = lean_ctor_get(x_307, 1);
-lean_inc(x_309);
-if (lean_is_exclusive(x_307)) {
- lean_ctor_release(x_307, 0);
- lean_ctor_release(x_307, 1);
- x_310 = x_307;
+lean_dec(x_306);
+x_309 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_305, x_308, x_8, x_283, x_4, x_5, x_6, x_303);
+if (lean_obj_tag(x_309) == 0)
+{
+lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; 
+x_310 = lean_ctor_get(x_309, 0);
+lean_inc(x_310);
+x_311 = lean_ctor_get(x_309, 1);
+lean_inc(x_311);
+if (lean_is_exclusive(x_309)) {
+ lean_ctor_release(x_309, 0);
+ lean_ctor_release(x_309, 1);
+ x_312 = x_309;
 } else {
- lean_dec_ref(x_307);
- x_310 = lean_box(0);
+ lean_dec_ref(x_309);
+ x_312 = lean_box(0);
 }
-if (lean_is_scalar(x_310)) {
- x_311 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_312)) {
+ x_313 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_311 = x_310;
+ x_313 = x_312;
 }
-lean_ctor_set(x_311, 0, x_308);
-lean_ctor_set(x_311, 1, x_309);
-return x_311;
+lean_ctor_set(x_313, 0, x_310);
+lean_ctor_set(x_313, 1, x_311);
+return x_313;
 }
 else
 {
-lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; 
-x_312 = lean_ctor_get(x_307, 0);
-lean_inc(x_312);
-x_313 = lean_ctor_get(x_307, 1);
-lean_inc(x_313);
-if (lean_is_exclusive(x_307)) {
- lean_ctor_release(x_307, 0);
- lean_ctor_release(x_307, 1);
- x_314 = x_307;
+lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; 
+x_314 = lean_ctor_get(x_309, 0);
+lean_inc(x_314);
+x_315 = lean_ctor_get(x_309, 1);
+lean_inc(x_315);
+if (lean_is_exclusive(x_309)) {
+ lean_ctor_release(x_309, 0);
+ lean_ctor_release(x_309, 1);
+ x_316 = x_309;
 } else {
- lean_dec_ref(x_307);
- x_314 = lean_box(0);
+ lean_dec_ref(x_309);
+ x_316 = lean_box(0);
 }
-if (lean_is_scalar(x_314)) {
- x_315 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_316)) {
+ x_317 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_315 = x_314;
+ x_317 = x_316;
 }
-lean_ctor_set(x_315, 0, x_312);
-lean_ctor_set(x_315, 1, x_313);
-return x_315;
+lean_ctor_set(x_317, 0, x_314);
+lean_ctor_set(x_317, 1, x_315);
+return x_317;
 }
 }
 }
 case 2:
 {
-lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; 
-x_316 = lean_ctor_get(x_283, 1);
-lean_inc(x_316);
-if (lean_is_exclusive(x_283)) {
- lean_ctor_release(x_283, 0);
- lean_ctor_release(x_283, 1);
- x_317 = x_283;
-} else {
- lean_dec_ref(x_283);
- x_317 = lean_box(0);
-}
-x_318 = lean_ctor_get(x_284, 1);
+lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; 
+x_318 = lean_ctor_get(x_285, 1);
 lean_inc(x_318);
-lean_dec(x_284);
-x_319 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__7___rarg(x_1, x_285);
-lean_dec(x_285);
-if (lean_obj_tag(x_319) == 0)
+if (lean_is_exclusive(x_285)) {
+ lean_ctor_release(x_285, 0);
+ lean_ctor_release(x_285, 1);
+ x_319 = x_285;
+} else {
+ lean_dec_ref(x_285);
+ x_319 = lean_box(0);
+}
+x_320 = lean_ctor_get(x_286, 1);
+lean_inc(x_320);
+lean_dec(x_286);
+x_321 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__7___rarg(x_1, x_287);
+lean_dec(x_287);
+if (lean_obj_tag(x_321) == 0)
 {
-lean_object* x_320; 
-lean_dec(x_318);
-lean_dec(x_281);
+lean_object* x_322; 
+lean_dec(x_320);
+lean_dec(x_283);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_317)) {
- x_320 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_319)) {
+ x_322 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_320 = x_317;
+ x_322 = x_319;
 }
-lean_ctor_set(x_320, 0, x_8);
-lean_ctor_set(x_320, 1, x_316);
-return x_320;
+lean_ctor_set(x_322, 0, x_8);
+lean_ctor_set(x_322, 1, x_318);
+return x_322;
 }
 else
 {
-lean_object* x_321; lean_object* x_322; 
-lean_dec(x_317);
-x_321 = lean_ctor_get(x_319, 0);
-lean_inc(x_321);
+lean_object* x_323; lean_object* x_324; 
 lean_dec(x_319);
-x_322 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_318, x_321, x_8, x_281, x_4, x_5, x_6, x_316);
-if (lean_obj_tag(x_322) == 0)
-{
-lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; 
-x_323 = lean_ctor_get(x_322, 0);
+x_323 = lean_ctor_get(x_321, 0);
 lean_inc(x_323);
-x_324 = lean_ctor_get(x_322, 1);
-lean_inc(x_324);
-if (lean_is_exclusive(x_322)) {
- lean_ctor_release(x_322, 0);
- lean_ctor_release(x_322, 1);
- x_325 = x_322;
+lean_dec(x_321);
+x_324 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_320, x_323, x_8, x_283, x_4, x_5, x_6, x_318);
+if (lean_obj_tag(x_324) == 0)
+{
+lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; 
+x_325 = lean_ctor_get(x_324, 0);
+lean_inc(x_325);
+x_326 = lean_ctor_get(x_324, 1);
+lean_inc(x_326);
+if (lean_is_exclusive(x_324)) {
+ lean_ctor_release(x_324, 0);
+ lean_ctor_release(x_324, 1);
+ x_327 = x_324;
 } else {
- lean_dec_ref(x_322);
- x_325 = lean_box(0);
+ lean_dec_ref(x_324);
+ x_327 = lean_box(0);
 }
-if (lean_is_scalar(x_325)) {
- x_326 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_327)) {
+ x_328 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_326 = x_325;
+ x_328 = x_327;
 }
-lean_ctor_set(x_326, 0, x_323);
-lean_ctor_set(x_326, 1, x_324);
-return x_326;
+lean_ctor_set(x_328, 0, x_325);
+lean_ctor_set(x_328, 1, x_326);
+return x_328;
 }
 else
 {
-lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; 
-x_327 = lean_ctor_get(x_322, 0);
-lean_inc(x_327);
-x_328 = lean_ctor_get(x_322, 1);
-lean_inc(x_328);
-if (lean_is_exclusive(x_322)) {
- lean_ctor_release(x_322, 0);
- lean_ctor_release(x_322, 1);
- x_329 = x_322;
+lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; 
+x_329 = lean_ctor_get(x_324, 0);
+lean_inc(x_329);
+x_330 = lean_ctor_get(x_324, 1);
+lean_inc(x_330);
+if (lean_is_exclusive(x_324)) {
+ lean_ctor_release(x_324, 0);
+ lean_ctor_release(x_324, 1);
+ x_331 = x_324;
 } else {
- lean_dec_ref(x_322);
- x_329 = lean_box(0);
+ lean_dec_ref(x_324);
+ x_331 = lean_box(0);
 }
-if (lean_is_scalar(x_329)) {
- x_330 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_331)) {
+ x_332 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_330 = x_329;
+ x_332 = x_331;
 }
-lean_ctor_set(x_330, 0, x_327);
-lean_ctor_set(x_330, 1, x_328);
-return x_330;
+lean_ctor_set(x_332, 0, x_329);
+lean_ctor_set(x_332, 1, x_330);
+return x_332;
 }
 }
 }
 case 3:
 {
-lean_object* x_331; lean_object* x_332; lean_object* x_333; 
-lean_dec(x_284);
-lean_dec(x_281);
+lean_object* x_333; lean_object* x_334; lean_object* x_335; 
+lean_dec(x_286);
+lean_dec(x_283);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_331 = lean_ctor_get(x_283, 1);
-lean_inc(x_331);
-if (lean_is_exclusive(x_283)) {
- lean_ctor_release(x_283, 0);
- lean_ctor_release(x_283, 1);
- x_332 = x_283;
+x_333 = lean_ctor_get(x_285, 1);
+lean_inc(x_333);
+if (lean_is_exclusive(x_285)) {
+ lean_ctor_release(x_285, 0);
+ lean_ctor_release(x_285, 1);
+ x_334 = x_285;
 } else {
- lean_dec_ref(x_283);
- x_332 = lean_box(0);
+ lean_dec_ref(x_285);
+ x_334 = lean_box(0);
 }
-if (lean_is_scalar(x_332)) {
- x_333 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_334)) {
+ x_335 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_333 = x_332;
+ x_335 = x_334;
 }
-lean_ctor_set(x_333, 0, x_8);
-lean_ctor_set(x_333, 1, x_331);
-return x_333;
+lean_ctor_set(x_335, 0, x_8);
+lean_ctor_set(x_335, 1, x_333);
+return x_335;
 }
 case 4:
 {
-lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; 
-x_334 = lean_ctor_get(x_283, 1);
-lean_inc(x_334);
-if (lean_is_exclusive(x_283)) {
- lean_ctor_release(x_283, 0);
- lean_ctor_release(x_283, 1);
- x_335 = x_283;
-} else {
- lean_dec_ref(x_283);
- x_335 = lean_box(0);
-}
-x_336 = lean_ctor_get(x_284, 1);
+lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; 
+x_336 = lean_ctor_get(x_285, 1);
 lean_inc(x_336);
-lean_dec(x_284);
-x_337 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__10___rarg(x_1, x_285);
-if (lean_obj_tag(x_337) == 0)
+if (lean_is_exclusive(x_285)) {
+ lean_ctor_release(x_285, 0);
+ lean_ctor_release(x_285, 1);
+ x_337 = x_285;
+} else {
+ lean_dec_ref(x_285);
+ x_337 = lean_box(0);
+}
+x_338 = lean_ctor_get(x_286, 1);
+lean_inc(x_338);
+lean_dec(x_286);
+x_339 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__10___rarg(x_1, x_287);
+if (lean_obj_tag(x_339) == 0)
 {
-lean_object* x_338; 
-lean_dec(x_336);
-lean_dec(x_281);
+lean_object* x_340; 
+lean_dec(x_338);
+lean_dec(x_283);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_335)) {
- x_338 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_337)) {
+ x_340 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_338 = x_335;
+ x_340 = x_337;
 }
-lean_ctor_set(x_338, 0, x_8);
-lean_ctor_set(x_338, 1, x_334);
-return x_338;
+lean_ctor_set(x_340, 0, x_8);
+lean_ctor_set(x_340, 1, x_336);
+return x_340;
 }
 else
 {
-lean_object* x_339; lean_object* x_340; 
-lean_dec(x_335);
-x_339 = lean_ctor_get(x_337, 0);
-lean_inc(x_339);
+lean_object* x_341; lean_object* x_342; 
 lean_dec(x_337);
-x_340 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_336, x_339, x_8, x_281, x_4, x_5, x_6, x_334);
-if (lean_obj_tag(x_340) == 0)
-{
-lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; 
-x_341 = lean_ctor_get(x_340, 0);
+x_341 = lean_ctor_get(x_339, 0);
 lean_inc(x_341);
-x_342 = lean_ctor_get(x_340, 1);
-lean_inc(x_342);
-if (lean_is_exclusive(x_340)) {
- lean_ctor_release(x_340, 0);
- lean_ctor_release(x_340, 1);
- x_343 = x_340;
+lean_dec(x_339);
+x_342 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_338, x_341, x_8, x_283, x_4, x_5, x_6, x_336);
+if (lean_obj_tag(x_342) == 0)
+{
+lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; 
+x_343 = lean_ctor_get(x_342, 0);
+lean_inc(x_343);
+x_344 = lean_ctor_get(x_342, 1);
+lean_inc(x_344);
+if (lean_is_exclusive(x_342)) {
+ lean_ctor_release(x_342, 0);
+ lean_ctor_release(x_342, 1);
+ x_345 = x_342;
 } else {
- lean_dec_ref(x_340);
- x_343 = lean_box(0);
+ lean_dec_ref(x_342);
+ x_345 = lean_box(0);
 }
-if (lean_is_scalar(x_343)) {
- x_344 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_345)) {
+ x_346 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_344 = x_343;
+ x_346 = x_345;
 }
-lean_ctor_set(x_344, 0, x_341);
-lean_ctor_set(x_344, 1, x_342);
-return x_344;
+lean_ctor_set(x_346, 0, x_343);
+lean_ctor_set(x_346, 1, x_344);
+return x_346;
 }
 else
 {
-lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; 
-x_345 = lean_ctor_get(x_340, 0);
-lean_inc(x_345);
-x_346 = lean_ctor_get(x_340, 1);
-lean_inc(x_346);
-if (lean_is_exclusive(x_340)) {
- lean_ctor_release(x_340, 0);
- lean_ctor_release(x_340, 1);
- x_347 = x_340;
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; 
+x_347 = lean_ctor_get(x_342, 0);
+lean_inc(x_347);
+x_348 = lean_ctor_get(x_342, 1);
+lean_inc(x_348);
+if (lean_is_exclusive(x_342)) {
+ lean_ctor_release(x_342, 0);
+ lean_ctor_release(x_342, 1);
+ x_349 = x_342;
 } else {
- lean_dec_ref(x_340);
- x_347 = lean_box(0);
+ lean_dec_ref(x_342);
+ x_349 = lean_box(0);
 }
-if (lean_is_scalar(x_347)) {
- x_348 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_349)) {
+ x_350 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_348 = x_347;
+ x_350 = x_349;
 }
-lean_ctor_set(x_348, 0, x_345);
-lean_ctor_set(x_348, 1, x_346);
-return x_348;
+lean_ctor_set(x_350, 0, x_347);
+lean_ctor_set(x_350, 1, x_348);
+return x_350;
 }
 }
 }
 default: 
 {
-lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; 
-x_349 = lean_ctor_get(x_283, 1);
-lean_inc(x_349);
-if (lean_is_exclusive(x_283)) {
- lean_ctor_release(x_283, 0);
- lean_ctor_release(x_283, 1);
- x_350 = x_283;
-} else {
- lean_dec_ref(x_283);
- x_350 = lean_box(0);
-}
-x_351 = lean_ctor_get(x_284, 1);
+lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; 
+x_351 = lean_ctor_get(x_285, 1);
 lean_inc(x_351);
-lean_dec(x_284);
-x_352 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__13___rarg(x_1, x_285);
-if (lean_obj_tag(x_352) == 0)
+if (lean_is_exclusive(x_285)) {
+ lean_ctor_release(x_285, 0);
+ lean_ctor_release(x_285, 1);
+ x_352 = x_285;
+} else {
+ lean_dec_ref(x_285);
+ x_352 = lean_box(0);
+}
+x_353 = lean_ctor_get(x_286, 1);
+lean_inc(x_353);
+lean_dec(x_286);
+x_354 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__13___rarg(x_1, x_287);
+if (lean_obj_tag(x_354) == 0)
 {
-lean_object* x_353; 
-lean_dec(x_351);
-lean_dec(x_281);
+lean_object* x_355; 
+lean_dec(x_353);
+lean_dec(x_283);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_350)) {
- x_353 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_352)) {
+ x_355 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_353 = x_350;
+ x_355 = x_352;
 }
-lean_ctor_set(x_353, 0, x_8);
-lean_ctor_set(x_353, 1, x_349);
-return x_353;
+lean_ctor_set(x_355, 0, x_8);
+lean_ctor_set(x_355, 1, x_351);
+return x_355;
 }
 else
 {
-lean_object* x_354; lean_object* x_355; 
-lean_dec(x_350);
-x_354 = lean_ctor_get(x_352, 0);
-lean_inc(x_354);
+lean_object* x_356; lean_object* x_357; 
 lean_dec(x_352);
-x_355 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_351, x_354, x_8, x_281, x_4, x_5, x_6, x_349);
-if (lean_obj_tag(x_355) == 0)
-{
-lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; 
-x_356 = lean_ctor_get(x_355, 0);
+x_356 = lean_ctor_get(x_354, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_355, 1);
-lean_inc(x_357);
-if (lean_is_exclusive(x_355)) {
- lean_ctor_release(x_355, 0);
- lean_ctor_release(x_355, 1);
- x_358 = x_355;
+lean_dec(x_354);
+x_357 = l_Lean_Meta_DiscrTree_getMatch_process___rarg(x_353, x_356, x_8, x_283, x_4, x_5, x_6, x_351);
+if (lean_obj_tag(x_357) == 0)
+{
+lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; 
+x_358 = lean_ctor_get(x_357, 0);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_357, 1);
+lean_inc(x_359);
+if (lean_is_exclusive(x_357)) {
+ lean_ctor_release(x_357, 0);
+ lean_ctor_release(x_357, 1);
+ x_360 = x_357;
 } else {
- lean_dec_ref(x_355);
- x_358 = lean_box(0);
+ lean_dec_ref(x_357);
+ x_360 = lean_box(0);
 }
-if (lean_is_scalar(x_358)) {
- x_359 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_359 = x_358;
+ x_361 = x_360;
 }
-lean_ctor_set(x_359, 0, x_356);
-lean_ctor_set(x_359, 1, x_357);
-return x_359;
+lean_ctor_set(x_361, 0, x_358);
+lean_ctor_set(x_361, 1, x_359);
+return x_361;
 }
 else
 {
-lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; 
-x_360 = lean_ctor_get(x_355, 0);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_355, 1);
-lean_inc(x_361);
-if (lean_is_exclusive(x_355)) {
- lean_ctor_release(x_355, 0);
- lean_ctor_release(x_355, 1);
- x_362 = x_355;
+lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; 
+x_362 = lean_ctor_get(x_357, 0);
+lean_inc(x_362);
+x_363 = lean_ctor_get(x_357, 1);
+lean_inc(x_363);
+if (lean_is_exclusive(x_357)) {
+ lean_ctor_release(x_357, 0);
+ lean_ctor_release(x_357, 1);
+ x_364 = x_357;
 } else {
- lean_dec_ref(x_355);
- x_362 = lean_box(0);
+ lean_dec_ref(x_357);
+ x_364 = lean_box(0);
 }
-if (lean_is_scalar(x_362)) {
- x_363 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_364)) {
+ x_365 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_363 = x_362;
+ x_365 = x_364;
 }
-lean_ctor_set(x_363, 0, x_360);
-lean_ctor_set(x_363, 1, x_361);
-return x_363;
+lean_ctor_set(x_365, 0, x_362);
+lean_ctor_set(x_365, 1, x_363);
+return x_365;
 }
 }
 }
@@ -16367,33 +16375,33 @@ return x_363;
 }
 else
 {
-lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-lean_dec(x_281);
+lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; 
+lean_dec(x_283);
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_364 = lean_ctor_get(x_283, 0);
-lean_inc(x_364);
-x_365 = lean_ctor_get(x_283, 1);
-lean_inc(x_365);
-if (lean_is_exclusive(x_283)) {
- lean_ctor_release(x_283, 0);
- lean_ctor_release(x_283, 1);
- x_366 = x_283;
+x_366 = lean_ctor_get(x_285, 0);
+lean_inc(x_366);
+x_367 = lean_ctor_get(x_285, 1);
+lean_inc(x_367);
+if (lean_is_exclusive(x_285)) {
+ lean_ctor_release(x_285, 0);
+ lean_ctor_release(x_285, 1);
+ x_368 = x_285;
 } else {
- lean_dec_ref(x_283);
- x_366 = lean_box(0);
+ lean_dec_ref(x_285);
+ x_368 = lean_box(0);
 }
-if (lean_is_scalar(x_366)) {
- x_367 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_368)) {
+ x_369 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_367 = x_366;
+ x_369 = x_368;
 }
-lean_ctor_set(x_367, 0, x_364);
-lean_ctor_set(x_367, 1, x_365);
-return x_367;
+lean_ctor_set(x_369, 0, x_366);
+lean_ctor_set(x_369, 1, x_367);
+return x_369;
 }
 }
 }
@@ -24094,7 +24102,7 @@ return x_195;
 }
 else
 {
-uint8_t x_196; uint8_t x_197; uint8_t x_198; uint8_t x_199; uint8_t x_200; uint8_t x_201; uint8_t x_202; uint8_t x_203; uint8_t x_204; lean_object* x_205; uint8_t x_206; lean_object* x_207; 
+uint8_t x_196; uint8_t x_197; uint8_t x_198; uint8_t x_199; uint8_t x_200; uint8_t x_201; uint8_t x_202; uint8_t x_203; uint8_t x_204; uint8_t x_205; lean_object* x_206; uint8_t x_207; lean_object* x_208; 
 x_196 = lean_ctor_get_uint8(x_9, 0);
 x_197 = lean_ctor_get_uint8(x_9, 1);
 x_198 = lean_ctor_get_uint8(x_9, 2);
@@ -24103,567 +24111,569 @@ x_200 = lean_ctor_get_uint8(x_9, 4);
 x_201 = lean_ctor_get_uint8(x_9, 6);
 x_202 = lean_ctor_get_uint8(x_9, 7);
 x_203 = lean_ctor_get_uint8(x_9, 8);
+x_204 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_204 = 2;
-x_205 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_205, 0, x_196);
-lean_ctor_set_uint8(x_205, 1, x_197);
-lean_ctor_set_uint8(x_205, 2, x_198);
-lean_ctor_set_uint8(x_205, 3, x_199);
-lean_ctor_set_uint8(x_205, 4, x_200);
-lean_ctor_set_uint8(x_205, 5, x_204);
-lean_ctor_set_uint8(x_205, 6, x_201);
-lean_ctor_set_uint8(x_205, 7, x_202);
-lean_ctor_set_uint8(x_205, 8, x_203);
-lean_ctor_set(x_3, 0, x_205);
-x_206 = 0;
+x_205 = 2;
+x_206 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_206, 0, x_196);
+lean_ctor_set_uint8(x_206, 1, x_197);
+lean_ctor_set_uint8(x_206, 2, x_198);
+lean_ctor_set_uint8(x_206, 3, x_199);
+lean_ctor_set_uint8(x_206, 4, x_200);
+lean_ctor_set_uint8(x_206, 5, x_205);
+lean_ctor_set_uint8(x_206, 6, x_201);
+lean_ctor_set_uint8(x_206, 7, x_202);
+lean_ctor_set_uint8(x_206, 8, x_203);
+lean_ctor_set_uint8(x_206, 9, x_204);
+lean_ctor_set(x_3, 0, x_206);
+x_207 = 0;
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_207 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_206, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_207) == 0)
+x_208 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_207, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_208) == 0)
 {
-lean_object* x_208; lean_object* x_209; 
-x_208 = lean_ctor_get(x_207, 0);
-lean_inc(x_208);
+lean_object* x_209; lean_object* x_210; 
 x_209 = lean_ctor_get(x_208, 0);
 lean_inc(x_209);
-switch (lean_obj_tag(x_209)) {
+x_210 = lean_ctor_get(x_209, 0);
+lean_inc(x_210);
+switch (lean_obj_tag(x_210)) {
 case 0:
 {
-lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; 
-x_210 = lean_ctor_get(x_207, 1);
-lean_inc(x_210);
-if (lean_is_exclusive(x_207)) {
- lean_ctor_release(x_207, 0);
- lean_ctor_release(x_207, 1);
- x_211 = x_207;
+lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; 
+x_211 = lean_ctor_get(x_208, 1);
+lean_inc(x_211);
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ x_212 = x_208;
 } else {
- lean_dec_ref(x_207);
- x_211 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_212 = lean_box(0);
 }
-x_212 = lean_ctor_get(x_208, 1);
-lean_inc(x_212);
-lean_dec(x_208);
-lean_inc(x_1);
-x_213 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_214 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__1___rarg(x_1, x_209);
+x_213 = lean_ctor_get(x_209, 1);
+lean_inc(x_213);
 lean_dec(x_209);
-if (lean_obj_tag(x_214) == 0)
+lean_inc(x_1);
+x_214 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_215 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__1___rarg(x_1, x_210);
+lean_dec(x_210);
+if (lean_obj_tag(x_215) == 0)
 {
-lean_object* x_215; 
-lean_dec(x_212);
+lean_object* x_216; 
+lean_dec(x_213);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_211)) {
- x_215 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_212)) {
+ x_216 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_215 = x_211;
+ x_216 = x_212;
 }
-lean_ctor_set(x_215, 0, x_213);
-lean_ctor_set(x_215, 1, x_210);
-return x_215;
+lean_ctor_set(x_216, 0, x_214);
+lean_ctor_set(x_216, 1, x_211);
+return x_216;
 }
 else
 {
-lean_object* x_216; lean_object* x_217; lean_object* x_218; 
-lean_dec(x_211);
-x_216 = lean_ctor_get(x_214, 0);
-lean_inc(x_216);
-lean_dec(x_214);
-x_217 = lean_unsigned_to_nat(0u);
-x_218 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_217, x_212, x_216, x_213, x_3, x_4, x_5, x_6, x_210);
-if (lean_obj_tag(x_218) == 0)
+lean_object* x_217; lean_object* x_218; lean_object* x_219; 
+lean_dec(x_212);
+x_217 = lean_ctor_get(x_215, 0);
+lean_inc(x_217);
+lean_dec(x_215);
+x_218 = lean_unsigned_to_nat(0u);
+x_219 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_218, x_213, x_217, x_214, x_3, x_4, x_5, x_6, x_211);
+if (lean_obj_tag(x_219) == 0)
 {
-lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; 
-x_219 = lean_ctor_get(x_218, 0);
-lean_inc(x_219);
-x_220 = lean_ctor_get(x_218, 1);
+lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; 
+x_220 = lean_ctor_get(x_219, 0);
 lean_inc(x_220);
-if (lean_is_exclusive(x_218)) {
- lean_ctor_release(x_218, 0);
- lean_ctor_release(x_218, 1);
- x_221 = x_218;
+x_221 = lean_ctor_get(x_219, 1);
+lean_inc(x_221);
+if (lean_is_exclusive(x_219)) {
+ lean_ctor_release(x_219, 0);
+ lean_ctor_release(x_219, 1);
+ x_222 = x_219;
 } else {
- lean_dec_ref(x_218);
- x_221 = lean_box(0);
+ lean_dec_ref(x_219);
+ x_222 = lean_box(0);
 }
-if (lean_is_scalar(x_221)) {
- x_222 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_222)) {
+ x_223 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_222 = x_221;
+ x_223 = x_222;
 }
-lean_ctor_set(x_222, 0, x_219);
-lean_ctor_set(x_222, 1, x_220);
-return x_222;
+lean_ctor_set(x_223, 0, x_220);
+lean_ctor_set(x_223, 1, x_221);
+return x_223;
 }
 else
 {
-lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; 
-x_223 = lean_ctor_get(x_218, 0);
-lean_inc(x_223);
-x_224 = lean_ctor_get(x_218, 1);
+lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; 
+x_224 = lean_ctor_get(x_219, 0);
 lean_inc(x_224);
-if (lean_is_exclusive(x_218)) {
- lean_ctor_release(x_218, 0);
- lean_ctor_release(x_218, 1);
- x_225 = x_218;
+x_225 = lean_ctor_get(x_219, 1);
+lean_inc(x_225);
+if (lean_is_exclusive(x_219)) {
+ lean_ctor_release(x_219, 0);
+ lean_ctor_release(x_219, 1);
+ x_226 = x_219;
 } else {
- lean_dec_ref(x_218);
- x_225 = lean_box(0);
+ lean_dec_ref(x_219);
+ x_226 = lean_box(0);
 }
-if (lean_is_scalar(x_225)) {
- x_226 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_226)) {
+ x_227 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_226 = x_225;
+ x_227 = x_226;
 }
-lean_ctor_set(x_226, 0, x_223);
-lean_ctor_set(x_226, 1, x_224);
-return x_226;
+lean_ctor_set(x_227, 0, x_224);
+lean_ctor_set(x_227, 1, x_225);
+return x_227;
 }
 }
 }
 case 1:
 {
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; 
-x_227 = lean_ctor_get(x_207, 1);
-lean_inc(x_227);
-if (lean_is_exclusive(x_207)) {
- lean_ctor_release(x_207, 0);
- lean_ctor_release(x_207, 1);
- x_228 = x_207;
+lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; 
+x_228 = lean_ctor_get(x_208, 1);
+lean_inc(x_228);
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ x_229 = x_208;
 } else {
- lean_dec_ref(x_207);
- x_228 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_229 = lean_box(0);
 }
-x_229 = lean_ctor_get(x_208, 1);
-lean_inc(x_229);
-lean_dec(x_208);
-lean_inc(x_1);
-x_230 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_231 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__4___rarg(x_1, x_209);
+x_230 = lean_ctor_get(x_209, 1);
+lean_inc(x_230);
 lean_dec(x_209);
-if (lean_obj_tag(x_231) == 0)
+lean_inc(x_1);
+x_231 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_232 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__4___rarg(x_1, x_210);
+lean_dec(x_210);
+if (lean_obj_tag(x_232) == 0)
 {
-lean_object* x_232; 
-lean_dec(x_229);
+lean_object* x_233; 
+lean_dec(x_230);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_228)) {
- x_232 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_229)) {
+ x_233 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_232 = x_228;
+ x_233 = x_229;
 }
-lean_ctor_set(x_232, 0, x_230);
-lean_ctor_set(x_232, 1, x_227);
-return x_232;
+lean_ctor_set(x_233, 0, x_231);
+lean_ctor_set(x_233, 1, x_228);
+return x_233;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; 
-lean_dec(x_228);
-x_233 = lean_ctor_get(x_231, 0);
-lean_inc(x_233);
-lean_dec(x_231);
-x_234 = lean_unsigned_to_nat(0u);
-x_235 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_234, x_229, x_233, x_230, x_3, x_4, x_5, x_6, x_227);
-if (lean_obj_tag(x_235) == 0)
+lean_object* x_234; lean_object* x_235; lean_object* x_236; 
+lean_dec(x_229);
+x_234 = lean_ctor_get(x_232, 0);
+lean_inc(x_234);
+lean_dec(x_232);
+x_235 = lean_unsigned_to_nat(0u);
+x_236 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_235, x_230, x_234, x_231, x_3, x_4, x_5, x_6, x_228);
+if (lean_obj_tag(x_236) == 0)
 {
-lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; 
-x_236 = lean_ctor_get(x_235, 0);
-lean_inc(x_236);
-x_237 = lean_ctor_get(x_235, 1);
+lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; 
+x_237 = lean_ctor_get(x_236, 0);
 lean_inc(x_237);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- x_238 = x_235;
+x_238 = lean_ctor_get(x_236, 1);
+lean_inc(x_238);
+if (lean_is_exclusive(x_236)) {
+ lean_ctor_release(x_236, 0);
+ lean_ctor_release(x_236, 1);
+ x_239 = x_236;
 } else {
- lean_dec_ref(x_235);
- x_238 = lean_box(0);
+ lean_dec_ref(x_236);
+ x_239 = lean_box(0);
 }
-if (lean_is_scalar(x_238)) {
- x_239 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_239)) {
+ x_240 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_239 = x_238;
+ x_240 = x_239;
 }
-lean_ctor_set(x_239, 0, x_236);
-lean_ctor_set(x_239, 1, x_237);
-return x_239;
+lean_ctor_set(x_240, 0, x_237);
+lean_ctor_set(x_240, 1, x_238);
+return x_240;
 }
 else
 {
-lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; 
-x_240 = lean_ctor_get(x_235, 0);
-lean_inc(x_240);
-x_241 = lean_ctor_get(x_235, 1);
+lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; 
+x_241 = lean_ctor_get(x_236, 0);
 lean_inc(x_241);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- x_242 = x_235;
+x_242 = lean_ctor_get(x_236, 1);
+lean_inc(x_242);
+if (lean_is_exclusive(x_236)) {
+ lean_ctor_release(x_236, 0);
+ lean_ctor_release(x_236, 1);
+ x_243 = x_236;
 } else {
- lean_dec_ref(x_235);
- x_242 = lean_box(0);
+ lean_dec_ref(x_236);
+ x_243 = lean_box(0);
 }
-if (lean_is_scalar(x_242)) {
- x_243 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_243)) {
+ x_244 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_243 = x_242;
+ x_244 = x_243;
 }
-lean_ctor_set(x_243, 0, x_240);
-lean_ctor_set(x_243, 1, x_241);
-return x_243;
+lean_ctor_set(x_244, 0, x_241);
+lean_ctor_set(x_244, 1, x_242);
+return x_244;
 }
 }
 }
 case 2:
 {
-lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; 
-x_244 = lean_ctor_get(x_207, 1);
-lean_inc(x_244);
-if (lean_is_exclusive(x_207)) {
- lean_ctor_release(x_207, 0);
- lean_ctor_release(x_207, 1);
- x_245 = x_207;
+lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; 
+x_245 = lean_ctor_get(x_208, 1);
+lean_inc(x_245);
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ x_246 = x_208;
 } else {
- lean_dec_ref(x_207);
- x_245 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_246 = lean_box(0);
 }
-x_246 = lean_ctor_get(x_208, 1);
-lean_inc(x_246);
-lean_dec(x_208);
-lean_inc(x_1);
-x_247 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_248 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__7___rarg(x_1, x_209);
+x_247 = lean_ctor_get(x_209, 1);
+lean_inc(x_247);
 lean_dec(x_209);
-if (lean_obj_tag(x_248) == 0)
+lean_inc(x_1);
+x_248 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_249 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__7___rarg(x_1, x_210);
+lean_dec(x_210);
+if (lean_obj_tag(x_249) == 0)
 {
-lean_object* x_249; 
-lean_dec(x_246);
+lean_object* x_250; 
+lean_dec(x_247);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_245)) {
- x_249 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_246)) {
+ x_250 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_249 = x_245;
+ x_250 = x_246;
 }
-lean_ctor_set(x_249, 0, x_247);
-lean_ctor_set(x_249, 1, x_244);
-return x_249;
+lean_ctor_set(x_250, 0, x_248);
+lean_ctor_set(x_250, 1, x_245);
+return x_250;
 }
 else
 {
-lean_object* x_250; lean_object* x_251; lean_object* x_252; 
-lean_dec(x_245);
-x_250 = lean_ctor_get(x_248, 0);
-lean_inc(x_250);
-lean_dec(x_248);
-x_251 = lean_unsigned_to_nat(0u);
-x_252 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_251, x_246, x_250, x_247, x_3, x_4, x_5, x_6, x_244);
-if (lean_obj_tag(x_252) == 0)
+lean_object* x_251; lean_object* x_252; lean_object* x_253; 
+lean_dec(x_246);
+x_251 = lean_ctor_get(x_249, 0);
+lean_inc(x_251);
+lean_dec(x_249);
+x_252 = lean_unsigned_to_nat(0u);
+x_253 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_252, x_247, x_251, x_248, x_3, x_4, x_5, x_6, x_245);
+if (lean_obj_tag(x_253) == 0)
 {
-lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; 
-x_253 = lean_ctor_get(x_252, 0);
-lean_inc(x_253);
-x_254 = lean_ctor_get(x_252, 1);
+lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; 
+x_254 = lean_ctor_get(x_253, 0);
 lean_inc(x_254);
-if (lean_is_exclusive(x_252)) {
- lean_ctor_release(x_252, 0);
- lean_ctor_release(x_252, 1);
- x_255 = x_252;
+x_255 = lean_ctor_get(x_253, 1);
+lean_inc(x_255);
+if (lean_is_exclusive(x_253)) {
+ lean_ctor_release(x_253, 0);
+ lean_ctor_release(x_253, 1);
+ x_256 = x_253;
 } else {
- lean_dec_ref(x_252);
- x_255 = lean_box(0);
+ lean_dec_ref(x_253);
+ x_256 = lean_box(0);
 }
-if (lean_is_scalar(x_255)) {
- x_256 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_256)) {
+ x_257 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_256 = x_255;
+ x_257 = x_256;
 }
-lean_ctor_set(x_256, 0, x_253);
-lean_ctor_set(x_256, 1, x_254);
-return x_256;
+lean_ctor_set(x_257, 0, x_254);
+lean_ctor_set(x_257, 1, x_255);
+return x_257;
 }
 else
 {
-lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; 
-x_257 = lean_ctor_get(x_252, 0);
-lean_inc(x_257);
-x_258 = lean_ctor_get(x_252, 1);
+lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; 
+x_258 = lean_ctor_get(x_253, 0);
 lean_inc(x_258);
-if (lean_is_exclusive(x_252)) {
- lean_ctor_release(x_252, 0);
- lean_ctor_release(x_252, 1);
- x_259 = x_252;
+x_259 = lean_ctor_get(x_253, 1);
+lean_inc(x_259);
+if (lean_is_exclusive(x_253)) {
+ lean_ctor_release(x_253, 0);
+ lean_ctor_release(x_253, 1);
+ x_260 = x_253;
 } else {
- lean_dec_ref(x_252);
- x_259 = lean_box(0);
+ lean_dec_ref(x_253);
+ x_260 = lean_box(0);
 }
-if (lean_is_scalar(x_259)) {
- x_260 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_260)) {
+ x_261 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_260 = x_259;
+ x_261 = x_260;
 }
-lean_ctor_set(x_260, 0, x_257);
-lean_ctor_set(x_260, 1, x_258);
-return x_260;
+lean_ctor_set(x_261, 0, x_258);
+lean_ctor_set(x_261, 1, x_259);
+return x_261;
 }
 }
 }
 case 3:
 {
-lean_object* x_261; lean_object* x_262; lean_object* x_263; 
+lean_object* x_262; lean_object* x_263; lean_object* x_264; 
+lean_dec(x_209);
+x_262 = lean_ctor_get(x_208, 1);
+lean_inc(x_262);
 lean_dec(x_208);
-x_261 = lean_ctor_get(x_207, 1);
-lean_inc(x_261);
-lean_dec(x_207);
-x_262 = l_Array_empty___closed__1;
-x_263 = l_Std_PersistentHashMap_foldlM___at_Lean_Meta_DiscrTree_getUnify___spec__10___rarg(x_1, x_262, x_3, x_4, x_5, x_6, x_261);
+x_263 = l_Array_empty___closed__1;
+x_264 = l_Std_PersistentHashMap_foldlM___at_Lean_Meta_DiscrTree_getUnify___spec__10___rarg(x_1, x_263, x_3, x_4, x_5, x_6, x_262);
 lean_dec(x_1);
-if (lean_obj_tag(x_263) == 0)
+if (lean_obj_tag(x_264) == 0)
 {
-lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; 
-x_264 = lean_ctor_get(x_263, 0);
-lean_inc(x_264);
-x_265 = lean_ctor_get(x_263, 1);
+lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; 
+x_265 = lean_ctor_get(x_264, 0);
 lean_inc(x_265);
-if (lean_is_exclusive(x_263)) {
- lean_ctor_release(x_263, 0);
- lean_ctor_release(x_263, 1);
- x_266 = x_263;
+x_266 = lean_ctor_get(x_264, 1);
+lean_inc(x_266);
+if (lean_is_exclusive(x_264)) {
+ lean_ctor_release(x_264, 0);
+ lean_ctor_release(x_264, 1);
+ x_267 = x_264;
 } else {
- lean_dec_ref(x_263);
- x_266 = lean_box(0);
+ lean_dec_ref(x_264);
+ x_267 = lean_box(0);
 }
-if (lean_is_scalar(x_266)) {
- x_267 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_267)) {
+ x_268 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_267 = x_266;
+ x_268 = x_267;
 }
-lean_ctor_set(x_267, 0, x_264);
-lean_ctor_set(x_267, 1, x_265);
-return x_267;
+lean_ctor_set(x_268, 0, x_265);
+lean_ctor_set(x_268, 1, x_266);
+return x_268;
 }
 else
 {
-lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; 
-x_268 = lean_ctor_get(x_263, 0);
-lean_inc(x_268);
-x_269 = lean_ctor_get(x_263, 1);
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; 
+x_269 = lean_ctor_get(x_264, 0);
 lean_inc(x_269);
-if (lean_is_exclusive(x_263)) {
- lean_ctor_release(x_263, 0);
- lean_ctor_release(x_263, 1);
- x_270 = x_263;
+x_270 = lean_ctor_get(x_264, 1);
+lean_inc(x_270);
+if (lean_is_exclusive(x_264)) {
+ lean_ctor_release(x_264, 0);
+ lean_ctor_release(x_264, 1);
+ x_271 = x_264;
 } else {
- lean_dec_ref(x_263);
- x_270 = lean_box(0);
+ lean_dec_ref(x_264);
+ x_271 = lean_box(0);
 }
-if (lean_is_scalar(x_270)) {
- x_271 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_271)) {
+ x_272 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_271 = x_270;
+ x_272 = x_271;
 }
-lean_ctor_set(x_271, 0, x_268);
-lean_ctor_set(x_271, 1, x_269);
-return x_271;
+lean_ctor_set(x_272, 0, x_269);
+lean_ctor_set(x_272, 1, x_270);
+return x_272;
 }
 }
 case 4:
 {
-lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; 
-x_272 = lean_ctor_get(x_207, 1);
-lean_inc(x_272);
-if (lean_is_exclusive(x_207)) {
- lean_ctor_release(x_207, 0);
- lean_ctor_release(x_207, 1);
- x_273 = x_207;
+lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; 
+x_273 = lean_ctor_get(x_208, 1);
+lean_inc(x_273);
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ x_274 = x_208;
 } else {
- lean_dec_ref(x_207);
- x_273 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_274 = lean_box(0);
 }
-x_274 = lean_ctor_get(x_208, 1);
-lean_inc(x_274);
-lean_dec(x_208);
+x_275 = lean_ctor_get(x_209, 1);
+lean_inc(x_275);
+lean_dec(x_209);
 lean_inc(x_1);
-x_275 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_276 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__14___rarg(x_1, x_209);
-if (lean_obj_tag(x_276) == 0)
+x_276 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_277 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__14___rarg(x_1, x_210);
+if (lean_obj_tag(x_277) == 0)
 {
-lean_object* x_277; 
-lean_dec(x_274);
+lean_object* x_278; 
+lean_dec(x_275);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_273)) {
- x_277 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_274)) {
+ x_278 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_277 = x_273;
+ x_278 = x_274;
 }
-lean_ctor_set(x_277, 0, x_275);
-lean_ctor_set(x_277, 1, x_272);
-return x_277;
+lean_ctor_set(x_278, 0, x_276);
+lean_ctor_set(x_278, 1, x_273);
+return x_278;
 }
 else
 {
-lean_object* x_278; lean_object* x_279; lean_object* x_280; 
-lean_dec(x_273);
-x_278 = lean_ctor_get(x_276, 0);
-lean_inc(x_278);
-lean_dec(x_276);
-x_279 = lean_unsigned_to_nat(0u);
-x_280 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_279, x_274, x_278, x_275, x_3, x_4, x_5, x_6, x_272);
-if (lean_obj_tag(x_280) == 0)
+lean_object* x_279; lean_object* x_280; lean_object* x_281; 
+lean_dec(x_274);
+x_279 = lean_ctor_get(x_277, 0);
+lean_inc(x_279);
+lean_dec(x_277);
+x_280 = lean_unsigned_to_nat(0u);
+x_281 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_280, x_275, x_279, x_276, x_3, x_4, x_5, x_6, x_273);
+if (lean_obj_tag(x_281) == 0)
 {
-lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; 
-x_281 = lean_ctor_get(x_280, 0);
-lean_inc(x_281);
-x_282 = lean_ctor_get(x_280, 1);
+lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; 
+x_282 = lean_ctor_get(x_281, 0);
 lean_inc(x_282);
-if (lean_is_exclusive(x_280)) {
- lean_ctor_release(x_280, 0);
- lean_ctor_release(x_280, 1);
- x_283 = x_280;
+x_283 = lean_ctor_get(x_281, 1);
+lean_inc(x_283);
+if (lean_is_exclusive(x_281)) {
+ lean_ctor_release(x_281, 0);
+ lean_ctor_release(x_281, 1);
+ x_284 = x_281;
 } else {
- lean_dec_ref(x_280);
- x_283 = lean_box(0);
+ lean_dec_ref(x_281);
+ x_284 = lean_box(0);
 }
-if (lean_is_scalar(x_283)) {
- x_284 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_284)) {
+ x_285 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_284 = x_283;
+ x_285 = x_284;
 }
-lean_ctor_set(x_284, 0, x_281);
-lean_ctor_set(x_284, 1, x_282);
-return x_284;
+lean_ctor_set(x_285, 0, x_282);
+lean_ctor_set(x_285, 1, x_283);
+return x_285;
 }
 else
 {
-lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; 
-x_285 = lean_ctor_get(x_280, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_280, 1);
+lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; 
+x_286 = lean_ctor_get(x_281, 0);
 lean_inc(x_286);
-if (lean_is_exclusive(x_280)) {
- lean_ctor_release(x_280, 0);
- lean_ctor_release(x_280, 1);
- x_287 = x_280;
+x_287 = lean_ctor_get(x_281, 1);
+lean_inc(x_287);
+if (lean_is_exclusive(x_281)) {
+ lean_ctor_release(x_281, 0);
+ lean_ctor_release(x_281, 1);
+ x_288 = x_281;
 } else {
- lean_dec_ref(x_280);
- x_287 = lean_box(0);
+ lean_dec_ref(x_281);
+ x_288 = lean_box(0);
 }
-if (lean_is_scalar(x_287)) {
- x_288 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_288)) {
+ x_289 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_288 = x_287;
+ x_289 = x_288;
 }
-lean_ctor_set(x_288, 0, x_285);
-lean_ctor_set(x_288, 1, x_286);
-return x_288;
+lean_ctor_set(x_289, 0, x_286);
+lean_ctor_set(x_289, 1, x_287);
+return x_289;
 }
 }
 }
 default: 
 {
-lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_289 = lean_ctor_get(x_207, 1);
-lean_inc(x_289);
-if (lean_is_exclusive(x_207)) {
- lean_ctor_release(x_207, 0);
- lean_ctor_release(x_207, 1);
- x_290 = x_207;
+lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; 
+x_290 = lean_ctor_get(x_208, 1);
+lean_inc(x_290);
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ x_291 = x_208;
 } else {
- lean_dec_ref(x_207);
- x_290 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_291 = lean_box(0);
 }
-x_291 = lean_ctor_get(x_208, 1);
-lean_inc(x_291);
-lean_dec(x_208);
+x_292 = lean_ctor_get(x_209, 1);
+lean_inc(x_292);
+lean_dec(x_209);
 lean_inc(x_1);
-x_292 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_293 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__17___rarg(x_1, x_209);
-if (lean_obj_tag(x_293) == 0)
+x_293 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_294 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__17___rarg(x_1, x_210);
+if (lean_obj_tag(x_294) == 0)
 {
-lean_object* x_294; 
-lean_dec(x_291);
+lean_object* x_295; 
+lean_dec(x_292);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_290)) {
- x_294 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_291)) {
+ x_295 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_294 = x_290;
+ x_295 = x_291;
 }
-lean_ctor_set(x_294, 0, x_292);
-lean_ctor_set(x_294, 1, x_289);
-return x_294;
+lean_ctor_set(x_295, 0, x_293);
+lean_ctor_set(x_295, 1, x_290);
+return x_295;
 }
 else
 {
-lean_object* x_295; lean_object* x_296; lean_object* x_297; 
-lean_dec(x_290);
-x_295 = lean_ctor_get(x_293, 0);
-lean_inc(x_295);
-lean_dec(x_293);
-x_296 = lean_unsigned_to_nat(0u);
-x_297 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_296, x_291, x_295, x_292, x_3, x_4, x_5, x_6, x_289);
-if (lean_obj_tag(x_297) == 0)
+lean_object* x_296; lean_object* x_297; lean_object* x_298; 
+lean_dec(x_291);
+x_296 = lean_ctor_get(x_294, 0);
+lean_inc(x_296);
+lean_dec(x_294);
+x_297 = lean_unsigned_to_nat(0u);
+x_298 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_297, x_292, x_296, x_293, x_3, x_4, x_5, x_6, x_290);
+if (lean_obj_tag(x_298) == 0)
 {
-lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; 
-x_298 = lean_ctor_get(x_297, 0);
-lean_inc(x_298);
-x_299 = lean_ctor_get(x_297, 1);
+lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; 
+x_299 = lean_ctor_get(x_298, 0);
 lean_inc(x_299);
-if (lean_is_exclusive(x_297)) {
- lean_ctor_release(x_297, 0);
- lean_ctor_release(x_297, 1);
- x_300 = x_297;
+x_300 = lean_ctor_get(x_298, 1);
+lean_inc(x_300);
+if (lean_is_exclusive(x_298)) {
+ lean_ctor_release(x_298, 0);
+ lean_ctor_release(x_298, 1);
+ x_301 = x_298;
 } else {
- lean_dec_ref(x_297);
- x_300 = lean_box(0);
+ lean_dec_ref(x_298);
+ x_301 = lean_box(0);
 }
-if (lean_is_scalar(x_300)) {
- x_301 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_301)) {
+ x_302 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_301 = x_300;
+ x_302 = x_301;
 }
-lean_ctor_set(x_301, 0, x_298);
-lean_ctor_set(x_301, 1, x_299);
-return x_301;
+lean_ctor_set(x_302, 0, x_299);
+lean_ctor_set(x_302, 1, x_300);
+return x_302;
 }
 else
 {
-lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; 
-x_302 = lean_ctor_get(x_297, 0);
-lean_inc(x_302);
-x_303 = lean_ctor_get(x_297, 1);
+lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; 
+x_303 = lean_ctor_get(x_298, 0);
 lean_inc(x_303);
-if (lean_is_exclusive(x_297)) {
- lean_ctor_release(x_297, 0);
- lean_ctor_release(x_297, 1);
- x_304 = x_297;
+x_304 = lean_ctor_get(x_298, 1);
+lean_inc(x_304);
+if (lean_is_exclusive(x_298)) {
+ lean_ctor_release(x_298, 0);
+ lean_ctor_release(x_298, 1);
+ x_305 = x_298;
 } else {
- lean_dec_ref(x_297);
- x_304 = lean_box(0);
+ lean_dec_ref(x_298);
+ x_305 = lean_box(0);
 }
-if (lean_is_scalar(x_304)) {
- x_305 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_305)) {
+ x_306 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_305 = x_304;
+ x_306 = x_305;
 }
-lean_ctor_set(x_305, 0, x_302);
-lean_ctor_set(x_305, 1, x_303);
-return x_305;
+lean_ctor_set(x_306, 0, x_303);
+lean_ctor_set(x_306, 1, x_304);
+return x_306;
 }
 }
 }
@@ -24671,629 +24681,631 @@ return x_305;
 }
 else
 {
-lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; 
+lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; 
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_306 = lean_ctor_get(x_207, 0);
-lean_inc(x_306);
-x_307 = lean_ctor_get(x_207, 1);
+x_307 = lean_ctor_get(x_208, 0);
 lean_inc(x_307);
-if (lean_is_exclusive(x_207)) {
- lean_ctor_release(x_207, 0);
- lean_ctor_release(x_207, 1);
- x_308 = x_207;
+x_308 = lean_ctor_get(x_208, 1);
+lean_inc(x_308);
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ x_309 = x_208;
 } else {
- lean_dec_ref(x_207);
- x_308 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_309 = lean_box(0);
 }
-if (lean_is_scalar(x_308)) {
- x_309 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_309)) {
+ x_310 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_309 = x_308;
+ x_310 = x_309;
 }
-lean_ctor_set(x_309, 0, x_306);
-lean_ctor_set(x_309, 1, x_307);
-return x_309;
+lean_ctor_set(x_310, 0, x_307);
+lean_ctor_set(x_310, 1, x_308);
+return x_310;
 }
 }
 }
 else
 {
-lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; uint8_t x_314; uint8_t x_315; uint8_t x_316; uint8_t x_317; uint8_t x_318; uint8_t x_319; uint8_t x_320; uint8_t x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; uint8_t x_326; lean_object* x_327; 
-x_310 = lean_ctor_get(x_3, 0);
-x_311 = lean_ctor_get(x_3, 1);
-x_312 = lean_ctor_get(x_3, 2);
-x_313 = lean_ctor_get(x_3, 3);
+lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; uint8_t x_315; uint8_t x_316; uint8_t x_317; uint8_t x_318; uint8_t x_319; uint8_t x_320; uint8_t x_321; uint8_t x_322; uint8_t x_323; lean_object* x_324; uint8_t x_325; lean_object* x_326; lean_object* x_327; uint8_t x_328; lean_object* x_329; 
+x_311 = lean_ctor_get(x_3, 0);
+x_312 = lean_ctor_get(x_3, 1);
+x_313 = lean_ctor_get(x_3, 2);
+x_314 = lean_ctor_get(x_3, 3);
+lean_inc(x_314);
 lean_inc(x_313);
 lean_inc(x_312);
 lean_inc(x_311);
-lean_inc(x_310);
 lean_dec(x_3);
-x_314 = lean_ctor_get_uint8(x_310, 0);
-x_315 = lean_ctor_get_uint8(x_310, 1);
-x_316 = lean_ctor_get_uint8(x_310, 2);
-x_317 = lean_ctor_get_uint8(x_310, 3);
-x_318 = lean_ctor_get_uint8(x_310, 4);
-x_319 = lean_ctor_get_uint8(x_310, 6);
-x_320 = lean_ctor_get_uint8(x_310, 7);
-x_321 = lean_ctor_get_uint8(x_310, 8);
-if (lean_is_exclusive(x_310)) {
- x_322 = x_310;
+x_315 = lean_ctor_get_uint8(x_311, 0);
+x_316 = lean_ctor_get_uint8(x_311, 1);
+x_317 = lean_ctor_get_uint8(x_311, 2);
+x_318 = lean_ctor_get_uint8(x_311, 3);
+x_319 = lean_ctor_get_uint8(x_311, 4);
+x_320 = lean_ctor_get_uint8(x_311, 6);
+x_321 = lean_ctor_get_uint8(x_311, 7);
+x_322 = lean_ctor_get_uint8(x_311, 8);
+x_323 = lean_ctor_get_uint8(x_311, 9);
+if (lean_is_exclusive(x_311)) {
+ x_324 = x_311;
 } else {
- lean_dec_ref(x_310);
- x_322 = lean_box(0);
+ lean_dec_ref(x_311);
+ x_324 = lean_box(0);
 }
-x_323 = 2;
-if (lean_is_scalar(x_322)) {
- x_324 = lean_alloc_ctor(0, 0, 9);
+x_325 = 2;
+if (lean_is_scalar(x_324)) {
+ x_326 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_324 = x_322;
+ x_326 = x_324;
 }
-lean_ctor_set_uint8(x_324, 0, x_314);
-lean_ctor_set_uint8(x_324, 1, x_315);
-lean_ctor_set_uint8(x_324, 2, x_316);
-lean_ctor_set_uint8(x_324, 3, x_317);
-lean_ctor_set_uint8(x_324, 4, x_318);
-lean_ctor_set_uint8(x_324, 5, x_323);
-lean_ctor_set_uint8(x_324, 6, x_319);
-lean_ctor_set_uint8(x_324, 7, x_320);
-lean_ctor_set_uint8(x_324, 8, x_321);
-x_325 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_325, 0, x_324);
-lean_ctor_set(x_325, 1, x_311);
-lean_ctor_set(x_325, 2, x_312);
-lean_ctor_set(x_325, 3, x_313);
-x_326 = 0;
+lean_ctor_set_uint8(x_326, 0, x_315);
+lean_ctor_set_uint8(x_326, 1, x_316);
+lean_ctor_set_uint8(x_326, 2, x_317);
+lean_ctor_set_uint8(x_326, 3, x_318);
+lean_ctor_set_uint8(x_326, 4, x_319);
+lean_ctor_set_uint8(x_326, 5, x_325);
+lean_ctor_set_uint8(x_326, 6, x_320);
+lean_ctor_set_uint8(x_326, 7, x_321);
+lean_ctor_set_uint8(x_326, 8, x_322);
+lean_ctor_set_uint8(x_326, 9, x_323);
+x_327 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_327, 0, x_326);
+lean_ctor_set(x_327, 1, x_312);
+lean_ctor_set(x_327, 2, x_313);
+lean_ctor_set(x_327, 3, x_314);
+x_328 = 0;
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_325);
-x_327 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_326, x_325, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_327) == 0)
+lean_inc(x_327);
+x_329 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getKeyArgs(x_2, x_328, x_327, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_329) == 0)
 {
-lean_object* x_328; lean_object* x_329; 
-x_328 = lean_ctor_get(x_327, 0);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_328, 0);
-lean_inc(x_329);
-switch (lean_obj_tag(x_329)) {
+lean_object* x_330; lean_object* x_331; 
+x_330 = lean_ctor_get(x_329, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_330, 0);
+lean_inc(x_331);
+switch (lean_obj_tag(x_331)) {
 case 0:
 {
-lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; 
-x_330 = lean_ctor_get(x_327, 1);
-lean_inc(x_330);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- x_331 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_331 = lean_box(0);
-}
-x_332 = lean_ctor_get(x_328, 1);
+lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; 
+x_332 = lean_ctor_get(x_329, 1);
 lean_inc(x_332);
-lean_dec(x_328);
+if (lean_is_exclusive(x_329)) {
+ lean_ctor_release(x_329, 0);
+ lean_ctor_release(x_329, 1);
+ x_333 = x_329;
+} else {
+ lean_dec_ref(x_329);
+ x_333 = lean_box(0);
+}
+x_334 = lean_ctor_get(x_330, 1);
+lean_inc(x_334);
+lean_dec(x_330);
 lean_inc(x_1);
-x_333 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_334 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__1___rarg(x_1, x_329);
-lean_dec(x_329);
-if (lean_obj_tag(x_334) == 0)
+x_335 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_336 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__1___rarg(x_1, x_331);
+lean_dec(x_331);
+if (lean_obj_tag(x_336) == 0)
 {
-lean_object* x_335; 
-lean_dec(x_332);
-lean_dec(x_325);
+lean_object* x_337; 
+lean_dec(x_334);
+lean_dec(x_327);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_331)) {
- x_335 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_333)) {
+ x_337 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_335 = x_331;
+ x_337 = x_333;
 }
-lean_ctor_set(x_335, 0, x_333);
-lean_ctor_set(x_335, 1, x_330);
-return x_335;
+lean_ctor_set(x_337, 0, x_335);
+lean_ctor_set(x_337, 1, x_332);
+return x_337;
 }
 else
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; 
-lean_dec(x_331);
-x_336 = lean_ctor_get(x_334, 0);
-lean_inc(x_336);
-lean_dec(x_334);
-x_337 = lean_unsigned_to_nat(0u);
-x_338 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_337, x_332, x_336, x_333, x_325, x_4, x_5, x_6, x_330);
-if (lean_obj_tag(x_338) == 0)
+lean_object* x_338; lean_object* x_339; lean_object* x_340; 
+lean_dec(x_333);
+x_338 = lean_ctor_get(x_336, 0);
+lean_inc(x_338);
+lean_dec(x_336);
+x_339 = lean_unsigned_to_nat(0u);
+x_340 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_339, x_334, x_338, x_335, x_327, x_4, x_5, x_6, x_332);
+if (lean_obj_tag(x_340) == 0)
 {
-lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; 
-x_339 = lean_ctor_get(x_338, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_338, 1);
-lean_inc(x_340);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- x_341 = x_338;
+lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; 
+x_341 = lean_ctor_get(x_340, 0);
+lean_inc(x_341);
+x_342 = lean_ctor_get(x_340, 1);
+lean_inc(x_342);
+if (lean_is_exclusive(x_340)) {
+ lean_ctor_release(x_340, 0);
+ lean_ctor_release(x_340, 1);
+ x_343 = x_340;
 } else {
- lean_dec_ref(x_338);
- x_341 = lean_box(0);
+ lean_dec_ref(x_340);
+ x_343 = lean_box(0);
 }
-if (lean_is_scalar(x_341)) {
- x_342 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_343)) {
+ x_344 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_342 = x_341;
+ x_344 = x_343;
 }
-lean_ctor_set(x_342, 0, x_339);
-lean_ctor_set(x_342, 1, x_340);
-return x_342;
+lean_ctor_set(x_344, 0, x_341);
+lean_ctor_set(x_344, 1, x_342);
+return x_344;
 }
 else
 {
-lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; 
-x_343 = lean_ctor_get(x_338, 0);
-lean_inc(x_343);
-x_344 = lean_ctor_get(x_338, 1);
-lean_inc(x_344);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- x_345 = x_338;
+lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; 
+x_345 = lean_ctor_get(x_340, 0);
+lean_inc(x_345);
+x_346 = lean_ctor_get(x_340, 1);
+lean_inc(x_346);
+if (lean_is_exclusive(x_340)) {
+ lean_ctor_release(x_340, 0);
+ lean_ctor_release(x_340, 1);
+ x_347 = x_340;
 } else {
- lean_dec_ref(x_338);
- x_345 = lean_box(0);
+ lean_dec_ref(x_340);
+ x_347 = lean_box(0);
 }
-if (lean_is_scalar(x_345)) {
- x_346 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_347)) {
+ x_348 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_346 = x_345;
+ x_348 = x_347;
 }
-lean_ctor_set(x_346, 0, x_343);
-lean_ctor_set(x_346, 1, x_344);
-return x_346;
+lean_ctor_set(x_348, 0, x_345);
+lean_ctor_set(x_348, 1, x_346);
+return x_348;
 }
 }
 }
 case 1:
 {
-lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; 
-x_347 = lean_ctor_get(x_327, 1);
-lean_inc(x_347);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- x_348 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_348 = lean_box(0);
-}
-x_349 = lean_ctor_get(x_328, 1);
+lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; 
+x_349 = lean_ctor_get(x_329, 1);
 lean_inc(x_349);
-lean_dec(x_328);
+if (lean_is_exclusive(x_329)) {
+ lean_ctor_release(x_329, 0);
+ lean_ctor_release(x_329, 1);
+ x_350 = x_329;
+} else {
+ lean_dec_ref(x_329);
+ x_350 = lean_box(0);
+}
+x_351 = lean_ctor_get(x_330, 1);
+lean_inc(x_351);
+lean_dec(x_330);
 lean_inc(x_1);
-x_350 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_351 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__4___rarg(x_1, x_329);
-lean_dec(x_329);
-if (lean_obj_tag(x_351) == 0)
+x_352 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_353 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__4___rarg(x_1, x_331);
+lean_dec(x_331);
+if (lean_obj_tag(x_353) == 0)
 {
-lean_object* x_352; 
-lean_dec(x_349);
-lean_dec(x_325);
+lean_object* x_354; 
+lean_dec(x_351);
+lean_dec(x_327);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_348)) {
- x_352 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_350)) {
+ x_354 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_352 = x_348;
+ x_354 = x_350;
 }
-lean_ctor_set(x_352, 0, x_350);
-lean_ctor_set(x_352, 1, x_347);
-return x_352;
+lean_ctor_set(x_354, 0, x_352);
+lean_ctor_set(x_354, 1, x_349);
+return x_354;
 }
 else
 {
-lean_object* x_353; lean_object* x_354; lean_object* x_355; 
-lean_dec(x_348);
-x_353 = lean_ctor_get(x_351, 0);
-lean_inc(x_353);
-lean_dec(x_351);
-x_354 = lean_unsigned_to_nat(0u);
-x_355 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_354, x_349, x_353, x_350, x_325, x_4, x_5, x_6, x_347);
-if (lean_obj_tag(x_355) == 0)
+lean_object* x_355; lean_object* x_356; lean_object* x_357; 
+lean_dec(x_350);
+x_355 = lean_ctor_get(x_353, 0);
+lean_inc(x_355);
+lean_dec(x_353);
+x_356 = lean_unsigned_to_nat(0u);
+x_357 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_356, x_351, x_355, x_352, x_327, x_4, x_5, x_6, x_349);
+if (lean_obj_tag(x_357) == 0)
 {
-lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; 
-x_356 = lean_ctor_get(x_355, 0);
-lean_inc(x_356);
-x_357 = lean_ctor_get(x_355, 1);
-lean_inc(x_357);
-if (lean_is_exclusive(x_355)) {
- lean_ctor_release(x_355, 0);
- lean_ctor_release(x_355, 1);
- x_358 = x_355;
+lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; 
+x_358 = lean_ctor_get(x_357, 0);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_357, 1);
+lean_inc(x_359);
+if (lean_is_exclusive(x_357)) {
+ lean_ctor_release(x_357, 0);
+ lean_ctor_release(x_357, 1);
+ x_360 = x_357;
 } else {
- lean_dec_ref(x_355);
- x_358 = lean_box(0);
+ lean_dec_ref(x_357);
+ x_360 = lean_box(0);
 }
-if (lean_is_scalar(x_358)) {
- x_359 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_359 = x_358;
+ x_361 = x_360;
 }
-lean_ctor_set(x_359, 0, x_356);
-lean_ctor_set(x_359, 1, x_357);
-return x_359;
+lean_ctor_set(x_361, 0, x_358);
+lean_ctor_set(x_361, 1, x_359);
+return x_361;
 }
 else
 {
-lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; 
-x_360 = lean_ctor_get(x_355, 0);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_355, 1);
-lean_inc(x_361);
-if (lean_is_exclusive(x_355)) {
- lean_ctor_release(x_355, 0);
- lean_ctor_release(x_355, 1);
- x_362 = x_355;
+lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; 
+x_362 = lean_ctor_get(x_357, 0);
+lean_inc(x_362);
+x_363 = lean_ctor_get(x_357, 1);
+lean_inc(x_363);
+if (lean_is_exclusive(x_357)) {
+ lean_ctor_release(x_357, 0);
+ lean_ctor_release(x_357, 1);
+ x_364 = x_357;
 } else {
- lean_dec_ref(x_355);
- x_362 = lean_box(0);
+ lean_dec_ref(x_357);
+ x_364 = lean_box(0);
 }
-if (lean_is_scalar(x_362)) {
- x_363 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_364)) {
+ x_365 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_363 = x_362;
+ x_365 = x_364;
 }
-lean_ctor_set(x_363, 0, x_360);
-lean_ctor_set(x_363, 1, x_361);
-return x_363;
+lean_ctor_set(x_365, 0, x_362);
+lean_ctor_set(x_365, 1, x_363);
+return x_365;
 }
 }
 }
 case 2:
 {
-lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; 
-x_364 = lean_ctor_get(x_327, 1);
-lean_inc(x_364);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- x_365 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_365 = lean_box(0);
-}
-x_366 = lean_ctor_get(x_328, 1);
+lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; 
+x_366 = lean_ctor_get(x_329, 1);
 lean_inc(x_366);
-lean_dec(x_328);
+if (lean_is_exclusive(x_329)) {
+ lean_ctor_release(x_329, 0);
+ lean_ctor_release(x_329, 1);
+ x_367 = x_329;
+} else {
+ lean_dec_ref(x_329);
+ x_367 = lean_box(0);
+}
+x_368 = lean_ctor_get(x_330, 1);
+lean_inc(x_368);
+lean_dec(x_330);
 lean_inc(x_1);
-x_367 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_368 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__7___rarg(x_1, x_329);
-lean_dec(x_329);
-if (lean_obj_tag(x_368) == 0)
+x_369 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_370 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__7___rarg(x_1, x_331);
+lean_dec(x_331);
+if (lean_obj_tag(x_370) == 0)
 {
-lean_object* x_369; 
-lean_dec(x_366);
-lean_dec(x_325);
+lean_object* x_371; 
+lean_dec(x_368);
+lean_dec(x_327);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_365)) {
- x_369 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_367)) {
+ x_371 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_369 = x_365;
+ x_371 = x_367;
 }
-lean_ctor_set(x_369, 0, x_367);
-lean_ctor_set(x_369, 1, x_364);
-return x_369;
+lean_ctor_set(x_371, 0, x_369);
+lean_ctor_set(x_371, 1, x_366);
+return x_371;
 }
 else
 {
-lean_object* x_370; lean_object* x_371; lean_object* x_372; 
-lean_dec(x_365);
-x_370 = lean_ctor_get(x_368, 0);
-lean_inc(x_370);
-lean_dec(x_368);
-x_371 = lean_unsigned_to_nat(0u);
-x_372 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_371, x_366, x_370, x_367, x_325, x_4, x_5, x_6, x_364);
-if (lean_obj_tag(x_372) == 0)
+lean_object* x_372; lean_object* x_373; lean_object* x_374; 
+lean_dec(x_367);
+x_372 = lean_ctor_get(x_370, 0);
+lean_inc(x_372);
+lean_dec(x_370);
+x_373 = lean_unsigned_to_nat(0u);
+x_374 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_373, x_368, x_372, x_369, x_327, x_4, x_5, x_6, x_366);
+if (lean_obj_tag(x_374) == 0)
 {
-lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; 
-x_373 = lean_ctor_get(x_372, 0);
-lean_inc(x_373);
-x_374 = lean_ctor_get(x_372, 1);
-lean_inc(x_374);
-if (lean_is_exclusive(x_372)) {
- lean_ctor_release(x_372, 0);
- lean_ctor_release(x_372, 1);
- x_375 = x_372;
+lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; 
+x_375 = lean_ctor_get(x_374, 0);
+lean_inc(x_375);
+x_376 = lean_ctor_get(x_374, 1);
+lean_inc(x_376);
+if (lean_is_exclusive(x_374)) {
+ lean_ctor_release(x_374, 0);
+ lean_ctor_release(x_374, 1);
+ x_377 = x_374;
 } else {
- lean_dec_ref(x_372);
- x_375 = lean_box(0);
+ lean_dec_ref(x_374);
+ x_377 = lean_box(0);
 }
-if (lean_is_scalar(x_375)) {
- x_376 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_377)) {
+ x_378 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_376 = x_375;
+ x_378 = x_377;
 }
-lean_ctor_set(x_376, 0, x_373);
-lean_ctor_set(x_376, 1, x_374);
-return x_376;
+lean_ctor_set(x_378, 0, x_375);
+lean_ctor_set(x_378, 1, x_376);
+return x_378;
 }
 else
 {
-lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; 
-x_377 = lean_ctor_get(x_372, 0);
-lean_inc(x_377);
-x_378 = lean_ctor_get(x_372, 1);
-lean_inc(x_378);
-if (lean_is_exclusive(x_372)) {
- lean_ctor_release(x_372, 0);
- lean_ctor_release(x_372, 1);
- x_379 = x_372;
+lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; 
+x_379 = lean_ctor_get(x_374, 0);
+lean_inc(x_379);
+x_380 = lean_ctor_get(x_374, 1);
+lean_inc(x_380);
+if (lean_is_exclusive(x_374)) {
+ lean_ctor_release(x_374, 0);
+ lean_ctor_release(x_374, 1);
+ x_381 = x_374;
 } else {
- lean_dec_ref(x_372);
- x_379 = lean_box(0);
+ lean_dec_ref(x_374);
+ x_381 = lean_box(0);
 }
-if (lean_is_scalar(x_379)) {
- x_380 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_381)) {
+ x_382 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_380 = x_379;
+ x_382 = x_381;
 }
-lean_ctor_set(x_380, 0, x_377);
-lean_ctor_set(x_380, 1, x_378);
-return x_380;
+lean_ctor_set(x_382, 0, x_379);
+lean_ctor_set(x_382, 1, x_380);
+return x_382;
 }
 }
 }
 case 3:
 {
-lean_object* x_381; lean_object* x_382; lean_object* x_383; 
-lean_dec(x_328);
-x_381 = lean_ctor_get(x_327, 1);
-lean_inc(x_381);
-lean_dec(x_327);
-x_382 = l_Array_empty___closed__1;
-x_383 = l_Std_PersistentHashMap_foldlM___at_Lean_Meta_DiscrTree_getUnify___spec__10___rarg(x_1, x_382, x_325, x_4, x_5, x_6, x_381);
+lean_object* x_383; lean_object* x_384; lean_object* x_385; 
+lean_dec(x_330);
+x_383 = lean_ctor_get(x_329, 1);
+lean_inc(x_383);
+lean_dec(x_329);
+x_384 = l_Array_empty___closed__1;
+x_385 = l_Std_PersistentHashMap_foldlM___at_Lean_Meta_DiscrTree_getUnify___spec__10___rarg(x_1, x_384, x_327, x_4, x_5, x_6, x_383);
 lean_dec(x_1);
-if (lean_obj_tag(x_383) == 0)
+if (lean_obj_tag(x_385) == 0)
 {
-lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_384 = lean_ctor_get(x_383, 0);
-lean_inc(x_384);
-x_385 = lean_ctor_get(x_383, 1);
-lean_inc(x_385);
-if (lean_is_exclusive(x_383)) {
- lean_ctor_release(x_383, 0);
- lean_ctor_release(x_383, 1);
- x_386 = x_383;
+lean_object* x_386; lean_object* x_387; lean_object* x_388; lean_object* x_389; 
+x_386 = lean_ctor_get(x_385, 0);
+lean_inc(x_386);
+x_387 = lean_ctor_get(x_385, 1);
+lean_inc(x_387);
+if (lean_is_exclusive(x_385)) {
+ lean_ctor_release(x_385, 0);
+ lean_ctor_release(x_385, 1);
+ x_388 = x_385;
 } else {
- lean_dec_ref(x_383);
- x_386 = lean_box(0);
+ lean_dec_ref(x_385);
+ x_388 = lean_box(0);
 }
-if (lean_is_scalar(x_386)) {
- x_387 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_388)) {
+ x_389 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_387 = x_386;
+ x_389 = x_388;
 }
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_385);
-return x_387;
+lean_ctor_set(x_389, 0, x_386);
+lean_ctor_set(x_389, 1, x_387);
+return x_389;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; 
-x_388 = lean_ctor_get(x_383, 0);
-lean_inc(x_388);
-x_389 = lean_ctor_get(x_383, 1);
-lean_inc(x_389);
-if (lean_is_exclusive(x_383)) {
- lean_ctor_release(x_383, 0);
- lean_ctor_release(x_383, 1);
- x_390 = x_383;
+lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; 
+x_390 = lean_ctor_get(x_385, 0);
+lean_inc(x_390);
+x_391 = lean_ctor_get(x_385, 1);
+lean_inc(x_391);
+if (lean_is_exclusive(x_385)) {
+ lean_ctor_release(x_385, 0);
+ lean_ctor_release(x_385, 1);
+ x_392 = x_385;
 } else {
- lean_dec_ref(x_383);
- x_390 = lean_box(0);
+ lean_dec_ref(x_385);
+ x_392 = lean_box(0);
 }
-if (lean_is_scalar(x_390)) {
- x_391 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_392)) {
+ x_393 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_391 = x_390;
+ x_393 = x_392;
 }
-lean_ctor_set(x_391, 0, x_388);
-lean_ctor_set(x_391, 1, x_389);
-return x_391;
+lean_ctor_set(x_393, 0, x_390);
+lean_ctor_set(x_393, 1, x_391);
+return x_393;
 }
 }
 case 4:
 {
-lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; 
-x_392 = lean_ctor_get(x_327, 1);
-lean_inc(x_392);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- x_393 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_393 = lean_box(0);
-}
-x_394 = lean_ctor_get(x_328, 1);
+lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; 
+x_394 = lean_ctor_get(x_329, 1);
 lean_inc(x_394);
-lean_dec(x_328);
+if (lean_is_exclusive(x_329)) {
+ lean_ctor_release(x_329, 0);
+ lean_ctor_release(x_329, 1);
+ x_395 = x_329;
+} else {
+ lean_dec_ref(x_329);
+ x_395 = lean_box(0);
+}
+x_396 = lean_ctor_get(x_330, 1);
+lean_inc(x_396);
+lean_dec(x_330);
 lean_inc(x_1);
-x_395 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_396 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__14___rarg(x_1, x_329);
-if (lean_obj_tag(x_396) == 0)
+x_397 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_398 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__14___rarg(x_1, x_331);
+if (lean_obj_tag(x_398) == 0)
 {
-lean_object* x_397; 
-lean_dec(x_394);
-lean_dec(x_325);
+lean_object* x_399; 
+lean_dec(x_396);
+lean_dec(x_327);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_393)) {
- x_397 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_395)) {
+ x_399 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_397 = x_393;
+ x_399 = x_395;
 }
-lean_ctor_set(x_397, 0, x_395);
-lean_ctor_set(x_397, 1, x_392);
-return x_397;
+lean_ctor_set(x_399, 0, x_397);
+lean_ctor_set(x_399, 1, x_394);
+return x_399;
 }
 else
 {
-lean_object* x_398; lean_object* x_399; lean_object* x_400; 
-lean_dec(x_393);
-x_398 = lean_ctor_get(x_396, 0);
-lean_inc(x_398);
-lean_dec(x_396);
-x_399 = lean_unsigned_to_nat(0u);
-x_400 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_399, x_394, x_398, x_395, x_325, x_4, x_5, x_6, x_392);
-if (lean_obj_tag(x_400) == 0)
+lean_object* x_400; lean_object* x_401; lean_object* x_402; 
+lean_dec(x_395);
+x_400 = lean_ctor_get(x_398, 0);
+lean_inc(x_400);
+lean_dec(x_398);
+x_401 = lean_unsigned_to_nat(0u);
+x_402 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_401, x_396, x_400, x_397, x_327, x_4, x_5, x_6, x_394);
+if (lean_obj_tag(x_402) == 0)
 {
-lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; 
-x_401 = lean_ctor_get(x_400, 0);
-lean_inc(x_401);
-x_402 = lean_ctor_get(x_400, 1);
-lean_inc(x_402);
-if (lean_is_exclusive(x_400)) {
- lean_ctor_release(x_400, 0);
- lean_ctor_release(x_400, 1);
- x_403 = x_400;
+lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; 
+x_403 = lean_ctor_get(x_402, 0);
+lean_inc(x_403);
+x_404 = lean_ctor_get(x_402, 1);
+lean_inc(x_404);
+if (lean_is_exclusive(x_402)) {
+ lean_ctor_release(x_402, 0);
+ lean_ctor_release(x_402, 1);
+ x_405 = x_402;
 } else {
- lean_dec_ref(x_400);
- x_403 = lean_box(0);
+ lean_dec_ref(x_402);
+ x_405 = lean_box(0);
 }
-if (lean_is_scalar(x_403)) {
- x_404 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_405)) {
+ x_406 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_404 = x_403;
+ x_406 = x_405;
 }
-lean_ctor_set(x_404, 0, x_401);
-lean_ctor_set(x_404, 1, x_402);
-return x_404;
+lean_ctor_set(x_406, 0, x_403);
+lean_ctor_set(x_406, 1, x_404);
+return x_406;
 }
 else
 {
-lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; 
-x_405 = lean_ctor_get(x_400, 0);
-lean_inc(x_405);
-x_406 = lean_ctor_get(x_400, 1);
-lean_inc(x_406);
-if (lean_is_exclusive(x_400)) {
- lean_ctor_release(x_400, 0);
- lean_ctor_release(x_400, 1);
- x_407 = x_400;
+lean_object* x_407; lean_object* x_408; lean_object* x_409; lean_object* x_410; 
+x_407 = lean_ctor_get(x_402, 0);
+lean_inc(x_407);
+x_408 = lean_ctor_get(x_402, 1);
+lean_inc(x_408);
+if (lean_is_exclusive(x_402)) {
+ lean_ctor_release(x_402, 0);
+ lean_ctor_release(x_402, 1);
+ x_409 = x_402;
 } else {
- lean_dec_ref(x_400);
- x_407 = lean_box(0);
+ lean_dec_ref(x_402);
+ x_409 = lean_box(0);
 }
-if (lean_is_scalar(x_407)) {
- x_408 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_409)) {
+ x_410 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_408 = x_407;
+ x_410 = x_409;
 }
-lean_ctor_set(x_408, 0, x_405);
-lean_ctor_set(x_408, 1, x_406);
-return x_408;
+lean_ctor_set(x_410, 0, x_407);
+lean_ctor_set(x_410, 1, x_408);
+return x_410;
 }
 }
 }
 default: 
 {
-lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; 
-x_409 = lean_ctor_get(x_327, 1);
-lean_inc(x_409);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- x_410 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_410 = lean_box(0);
-}
-x_411 = lean_ctor_get(x_328, 1);
+lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; 
+x_411 = lean_ctor_get(x_329, 1);
 lean_inc(x_411);
-lean_dec(x_328);
+if (lean_is_exclusive(x_329)) {
+ lean_ctor_release(x_329, 0);
+ lean_ctor_release(x_329, 1);
+ x_412 = x_329;
+} else {
+ lean_dec_ref(x_329);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_330, 1);
+lean_inc(x_413);
+lean_dec(x_330);
 lean_inc(x_1);
-x_412 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
-x_413 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__17___rarg(x_1, x_329);
-if (lean_obj_tag(x_413) == 0)
+x_414 = l___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___rarg(x_1);
+x_415 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__17___rarg(x_1, x_331);
+if (lean_obj_tag(x_415) == 0)
 {
-lean_object* x_414; 
-lean_dec(x_411);
-lean_dec(x_325);
+lean_object* x_416; 
+lean_dec(x_413);
+lean_dec(x_327);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-if (lean_is_scalar(x_410)) {
- x_414 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_412)) {
+ x_416 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_414 = x_410;
+ x_416 = x_412;
 }
-lean_ctor_set(x_414, 0, x_412);
-lean_ctor_set(x_414, 1, x_409);
-return x_414;
+lean_ctor_set(x_416, 0, x_414);
+lean_ctor_set(x_416, 1, x_411);
+return x_416;
 }
 else
 {
-lean_object* x_415; lean_object* x_416; lean_object* x_417; 
-lean_dec(x_410);
-x_415 = lean_ctor_get(x_413, 0);
-lean_inc(x_415);
-lean_dec(x_413);
-x_416 = lean_unsigned_to_nat(0u);
-x_417 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_416, x_411, x_415, x_412, x_325, x_4, x_5, x_6, x_409);
-if (lean_obj_tag(x_417) == 0)
+lean_object* x_417; lean_object* x_418; lean_object* x_419; 
+lean_dec(x_412);
+x_417 = lean_ctor_get(x_415, 0);
+lean_inc(x_417);
+lean_dec(x_415);
+x_418 = lean_unsigned_to_nat(0u);
+x_419 = l_Lean_Meta_DiscrTree_getUnify_process___rarg(x_418, x_413, x_417, x_414, x_327, x_4, x_5, x_6, x_411);
+if (lean_obj_tag(x_419) == 0)
 {
-lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; 
-x_418 = lean_ctor_get(x_417, 0);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_417, 1);
-lean_inc(x_419);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- x_420 = x_417;
+lean_object* x_420; lean_object* x_421; lean_object* x_422; lean_object* x_423; 
+x_420 = lean_ctor_get(x_419, 0);
+lean_inc(x_420);
+x_421 = lean_ctor_get(x_419, 1);
+lean_inc(x_421);
+if (lean_is_exclusive(x_419)) {
+ lean_ctor_release(x_419, 0);
+ lean_ctor_release(x_419, 1);
+ x_422 = x_419;
 } else {
- lean_dec_ref(x_417);
- x_420 = lean_box(0);
+ lean_dec_ref(x_419);
+ x_422 = lean_box(0);
 }
-if (lean_is_scalar(x_420)) {
- x_421 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_422)) {
+ x_423 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_421 = x_420;
+ x_423 = x_422;
 }
-lean_ctor_set(x_421, 0, x_418);
-lean_ctor_set(x_421, 1, x_419);
-return x_421;
+lean_ctor_set(x_423, 0, x_420);
+lean_ctor_set(x_423, 1, x_421);
+return x_423;
 }
 else
 {
-lean_object* x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_422 = lean_ctor_get(x_417, 0);
-lean_inc(x_422);
-x_423 = lean_ctor_get(x_417, 1);
-lean_inc(x_423);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- x_424 = x_417;
+lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; 
+x_424 = lean_ctor_get(x_419, 0);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_419, 1);
+lean_inc(x_425);
+if (lean_is_exclusive(x_419)) {
+ lean_ctor_release(x_419, 0);
+ lean_ctor_release(x_419, 1);
+ x_426 = x_419;
 } else {
- lean_dec_ref(x_417);
- x_424 = lean_box(0);
+ lean_dec_ref(x_419);
+ x_426 = lean_box(0);
 }
-if (lean_is_scalar(x_424)) {
- x_425 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_426)) {
+ x_427 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_425 = x_424;
+ x_427 = x_426;
 }
-lean_ctor_set(x_425, 0, x_422);
-lean_ctor_set(x_425, 1, x_423);
-return x_425;
+lean_ctor_set(x_427, 0, x_424);
+lean_ctor_set(x_427, 1, x_425);
+return x_427;
 }
 }
 }
@@ -25301,32 +25313,32 @@ return x_425;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; 
-lean_dec(x_325);
+lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; 
+lean_dec(x_327);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_426 = lean_ctor_get(x_327, 0);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_327, 1);
-lean_inc(x_427);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- x_428 = x_327;
+x_428 = lean_ctor_get(x_329, 0);
+lean_inc(x_428);
+x_429 = lean_ctor_get(x_329, 1);
+lean_inc(x_429);
+if (lean_is_exclusive(x_329)) {
+ lean_ctor_release(x_329, 0);
+ lean_ctor_release(x_329, 1);
+ x_430 = x_329;
 } else {
- lean_dec_ref(x_327);
- x_428 = lean_box(0);
+ lean_dec_ref(x_329);
+ x_430 = lean_box(0);
 }
-if (lean_is_scalar(x_428)) {
- x_429 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_430)) {
+ x_431 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_429 = x_428;
+ x_431 = x_430;
 }
-lean_ctor_set(x_429, 0, x_426);
-lean_ctor_set(x_429, 1, x_427);
-return x_429;
+lean_ctor_set(x_431, 0, x_428);
+lean_ctor_set(x_431, 1, x_429);
+return x_431;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/ExprDefEq.c b/stage0/stdlib/Lean/Meta/ExprDefEq.c
index e65804e551..357926dd30 100644
--- a/stage0/stdlib/Lean/Meta/ExprDefEq.c
+++ b/stage0/stdlib/Lean/Meta/ExprDefEq.c
@@ -318,6 +318,7 @@ lean_object* l_Lean_ConstantInfo_name(lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_unstuckMVar___closed__5;
 uint8_t l_Std_PersistentArray_anyM___at_Lean_Meta_CheckAssignment_checkMVar___spec__4(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_toCtorIfLit(lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Meta_CheckAssignment_checkMVar___spec__58(lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Lean_Meta_withNewLocalInstance___at___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isDefEqOffset(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -333,7 +334,6 @@ lean_object* l___private_Lean_MetavarContext_0__Lean_MetavarContext_DependsOn_de
 lean_object* l_Lean_Meta_CheckAssignment_run___closed__1;
 uint8_t l_Array_anyMUnsafe_any___at_Lean_Meta_CheckAssignment_checkMVar___spec__43(lean_object*, lean_object*, size_t, size_t);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_unfoldReducibeDefEq___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_unstuckMVar___closed__3;
 lean_object* l___private_Std_Data_PersistentArray_0__Std_PersistentArray_foldlMAux___at_Lean_Meta_CheckAssignment_checkMVar___spec__54(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_CheckAssignment_checkMVar___closed__3;
@@ -454,7 +454,6 @@ lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_unstuckMVar___closed__
 lean_object* l_Lean_LocalDecl_type(lean_object*);
 lean_object* l_Lean_LocalDecl_value_x3f(lean_object*);
 lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456____closed__1;
 lean_object* l_Lean_Meta_checkpointDefEq___at___private_Lean_Meta_ExprDefEq_0__Lean_Meta_tryHeuristic___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_checkpointDefEq___at___private_Lean_Meta_ExprDefEq_0__Lean_Meta_tryHeuristic___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_foldlM___at_Lean_Meta_CheckAssignment_checkMVar___spec__45(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -563,8 +562,8 @@ lean_object* l_Lean_Meta_CheckAssignment_checkMVar_match__2(lean_object*);
 uint8_t l_Lean_Expr_isFVar(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*);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_isAssigned_match__1(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9465_(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9483_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474_(lean_object*);
 lean_object* lean_expr_update_lambda(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_CheckAssignment_throwCheckAssignmentFailure___rarg___closed__1;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_checkAssignment___spec__1(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -599,6 +598,7 @@ lean_object* l_Lean_Meta_checkAssignment_match__1___rarg(lean_object*, lean_obje
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_checkAssignment___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_consumeLet(lean_object*);
 lean_object* l___private_Lean_MetavarContext_0__Lean_MetavarContext_DependsOn_dep_visit___at_Lean_Meta_CheckAssignment_checkMVar___spec__16___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474____closed__1;
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_processAssignmentFOApproxAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_mkLambdaFVarsWithLetDeps___closed__4;
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_isAssignable___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3388,7 +3388,7 @@ return x_32;
 }
 else
 {
-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; uint8_t x_42; uint8_t x_43; 
+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; uint8_t x_42; uint8_t x_43; uint8_t x_44; 
 x_33 = lean_ctor_get_uint8(x_10, 0);
 x_34 = lean_ctor_get_uint8(x_10, 1);
 x_35 = lean_ctor_get_uint8(x_10, 2);
@@ -3398,310 +3398,316 @@ x_38 = lean_ctor_get_uint8(x_10, 5);
 x_39 = lean_ctor_get_uint8(x_10, 6);
 x_40 = lean_ctor_get_uint8(x_10, 7);
 x_41 = lean_ctor_get_uint8(x_10, 8);
+x_42 = lean_ctor_get_uint8(x_10, 9);
 lean_dec(x_10);
-x_42 = 1;
-x_43 = l_Lean_Meta_TransparencyMode_lt(x_38, x_42);
-if (x_43 == 0)
+x_43 = 1;
+x_44 = l_Lean_Meta_TransparencyMode_lt(x_38, x_43);
+if (x_44 == 0)
 {
-lean_object* x_44; lean_object* x_45; 
-x_44 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_44, 0, x_33);
-lean_ctor_set_uint8(x_44, 1, x_34);
-lean_ctor_set_uint8(x_44, 2, x_35);
-lean_ctor_set_uint8(x_44, 3, x_36);
-lean_ctor_set_uint8(x_44, 4, x_37);
-lean_ctor_set_uint8(x_44, 5, x_38);
-lean_ctor_set_uint8(x_44, 6, x_39);
-lean_ctor_set_uint8(x_44, 7, x_40);
-lean_ctor_set_uint8(x_44, 8, x_41);
-lean_ctor_set(x_4, 0, x_44);
-x_45 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_4, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_45) == 0)
+lean_object* x_45; lean_object* x_46; 
+x_45 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_45, 0, x_33);
+lean_ctor_set_uint8(x_45, 1, x_34);
+lean_ctor_set_uint8(x_45, 2, x_35);
+lean_ctor_set_uint8(x_45, 3, x_36);
+lean_ctor_set_uint8(x_45, 4, x_37);
+lean_ctor_set_uint8(x_45, 5, x_38);
+lean_ctor_set_uint8(x_45, 6, x_39);
+lean_ctor_set_uint8(x_45, 7, x_40);
+lean_ctor_set_uint8(x_45, 8, x_41);
+lean_ctor_set_uint8(x_45, 9, x_42);
+lean_ctor_set(x_4, 0, x_45);
+x_46 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_4, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_46) == 0)
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_46 = lean_ctor_get(x_45, 0);
-lean_inc(x_46);
-x_47 = lean_ctor_get(x_45, 1);
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_47 = lean_ctor_get(x_46, 0);
 lean_inc(x_47);
-if (lean_is_exclusive(x_45)) {
- lean_ctor_release(x_45, 0);
- lean_ctor_release(x_45, 1);
- x_48 = x_45;
+x_48 = lean_ctor_get(x_46, 1);
+lean_inc(x_48);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ x_49 = x_46;
 } else {
- lean_dec_ref(x_45);
- x_48 = lean_box(0);
+ lean_dec_ref(x_46);
+ 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_46);
-lean_ctor_set(x_49, 1, x_47);
-return x_49;
+lean_ctor_set(x_50, 0, x_47);
+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; 
-x_50 = lean_ctor_get(x_45, 0);
-lean_inc(x_50);
-x_51 = lean_ctor_get(x_45, 1);
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_51 = lean_ctor_get(x_46, 0);
 lean_inc(x_51);
-if (lean_is_exclusive(x_45)) {
- lean_ctor_release(x_45, 0);
- lean_ctor_release(x_45, 1);
- x_52 = x_45;
+x_52 = lean_ctor_get(x_46, 1);
+lean_inc(x_52);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ x_53 = x_46;
 } else {
- lean_dec_ref(x_45);
- x_52 = lean_box(0);
+ lean_dec_ref(x_46);
+ x_53 = lean_box(0);
 }
-if (lean_is_scalar(x_52)) {
- x_53 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_53)) {
+ x_54 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_53 = x_52;
+ x_54 = x_53;
 }
-lean_ctor_set(x_53, 0, x_50);
-lean_ctor_set(x_53, 1, x_51);
-return x_53;
+lean_ctor_set(x_54, 0, x_51);
+lean_ctor_set(x_54, 1, x_52);
+return x_54;
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; 
-x_54 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_54, 0, x_33);
-lean_ctor_set_uint8(x_54, 1, x_34);
-lean_ctor_set_uint8(x_54, 2, x_35);
-lean_ctor_set_uint8(x_54, 3, x_36);
-lean_ctor_set_uint8(x_54, 4, x_37);
-lean_ctor_set_uint8(x_54, 5, x_42);
-lean_ctor_set_uint8(x_54, 6, x_39);
-lean_ctor_set_uint8(x_54, 7, x_40);
-lean_ctor_set_uint8(x_54, 8, x_41);
-lean_ctor_set(x_4, 0, x_54);
-x_55 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_4, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_55) == 0)
+lean_object* x_55; lean_object* x_56; 
+x_55 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_55, 0, x_33);
+lean_ctor_set_uint8(x_55, 1, x_34);
+lean_ctor_set_uint8(x_55, 2, x_35);
+lean_ctor_set_uint8(x_55, 3, x_36);
+lean_ctor_set_uint8(x_55, 4, x_37);
+lean_ctor_set_uint8(x_55, 5, x_43);
+lean_ctor_set_uint8(x_55, 6, x_39);
+lean_ctor_set_uint8(x_55, 7, x_40);
+lean_ctor_set_uint8(x_55, 8, x_41);
+lean_ctor_set_uint8(x_55, 9, x_42);
+lean_ctor_set(x_4, 0, x_55);
+x_56 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_4, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_56) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 1);
+lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_57 = lean_ctor_get(x_56, 0);
 lean_inc(x_57);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_58 = x_55;
+x_58 = lean_ctor_get(x_56, 1);
+lean_inc(x_58);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ x_59 = x_56;
 } else {
- lean_dec_ref(x_55);
- x_58 = lean_box(0);
+ lean_dec_ref(x_56);
+ x_59 = lean_box(0);
 }
-if (lean_is_scalar(x_58)) {
- x_59 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_59)) {
+ x_60 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_59 = x_58;
+ x_60 = x_59;
 }
-lean_ctor_set(x_59, 0, x_56);
-lean_ctor_set(x_59, 1, x_57);
-return x_59;
+lean_ctor_set(x_60, 0, x_57);
+lean_ctor_set(x_60, 1, x_58);
+return x_60;
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_60 = lean_ctor_get(x_55, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_55, 1);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_61 = lean_ctor_get(x_56, 0);
 lean_inc(x_61);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_62 = x_55;
+x_62 = lean_ctor_get(x_56, 1);
+lean_inc(x_62);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ x_63 = x_56;
 } else {
- lean_dec_ref(x_55);
- x_62 = lean_box(0);
+ lean_dec_ref(x_56);
+ x_63 = lean_box(0);
 }
-if (lean_is_scalar(x_62)) {
- x_63 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_63)) {
+ x_64 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_63 = x_62;
+ x_64 = x_63;
 }
-lean_ctor_set(x_63, 0, x_60);
-lean_ctor_set(x_63, 1, x_61);
-return 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_64; lean_object* x_65; lean_object* x_66; lean_object* 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; lean_object* x_77; uint8_t x_78; uint8_t x_79; 
-x_64 = lean_ctor_get(x_4, 0);
-x_65 = lean_ctor_get(x_4, 1);
-x_66 = lean_ctor_get(x_4, 2);
-x_67 = lean_ctor_get(x_4, 3);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* 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; uint8_t x_81; 
+x_65 = lean_ctor_get(x_4, 0);
+x_66 = lean_ctor_get(x_4, 1);
+x_67 = lean_ctor_get(x_4, 2);
+x_68 = lean_ctor_get(x_4, 3);
+lean_inc(x_68);
 lean_inc(x_67);
 lean_inc(x_66);
 lean_inc(x_65);
-lean_inc(x_64);
 lean_dec(x_4);
-x_68 = lean_ctor_get_uint8(x_64, 0);
-x_69 = lean_ctor_get_uint8(x_64, 1);
-x_70 = lean_ctor_get_uint8(x_64, 2);
-x_71 = lean_ctor_get_uint8(x_64, 3);
-x_72 = lean_ctor_get_uint8(x_64, 4);
-x_73 = lean_ctor_get_uint8(x_64, 5);
-x_74 = lean_ctor_get_uint8(x_64, 6);
-x_75 = lean_ctor_get_uint8(x_64, 7);
-x_76 = lean_ctor_get_uint8(x_64, 8);
-if (lean_is_exclusive(x_64)) {
- x_77 = x_64;
+x_69 = lean_ctor_get_uint8(x_65, 0);
+x_70 = lean_ctor_get_uint8(x_65, 1);
+x_71 = lean_ctor_get_uint8(x_65, 2);
+x_72 = lean_ctor_get_uint8(x_65, 3);
+x_73 = lean_ctor_get_uint8(x_65, 4);
+x_74 = lean_ctor_get_uint8(x_65, 5);
+x_75 = lean_ctor_get_uint8(x_65, 6);
+x_76 = lean_ctor_get_uint8(x_65, 7);
+x_77 = lean_ctor_get_uint8(x_65, 8);
+x_78 = lean_ctor_get_uint8(x_65, 9);
+if (lean_is_exclusive(x_65)) {
+ x_79 = x_65;
 } else {
- lean_dec_ref(x_64);
- x_77 = lean_box(0);
+ lean_dec_ref(x_65);
+ x_79 = lean_box(0);
 }
-x_78 = 1;
-x_79 = l_Lean_Meta_TransparencyMode_lt(x_73, x_78);
-if (x_79 == 0)
+x_80 = 1;
+x_81 = l_Lean_Meta_TransparencyMode_lt(x_74, x_80);
+if (x_81 == 0)
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-if (lean_is_scalar(x_77)) {
- x_80 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_82; lean_object* x_83; lean_object* x_84; 
+if (lean_is_scalar(x_79)) {
+ x_82 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_80 = x_77;
+ x_82 = x_79;
 }
-lean_ctor_set_uint8(x_80, 0, x_68);
-lean_ctor_set_uint8(x_80, 1, x_69);
-lean_ctor_set_uint8(x_80, 2, x_70);
-lean_ctor_set_uint8(x_80, 3, x_71);
-lean_ctor_set_uint8(x_80, 4, x_72);
-lean_ctor_set_uint8(x_80, 5, x_73);
-lean_ctor_set_uint8(x_80, 6, x_74);
-lean_ctor_set_uint8(x_80, 7, x_75);
-lean_ctor_set_uint8(x_80, 8, x_76);
-x_81 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_81, 0, x_80);
-lean_ctor_set(x_81, 1, x_65);
-lean_ctor_set(x_81, 2, x_66);
-lean_ctor_set(x_81, 3, x_67);
-x_82 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_81, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_82) == 0)
+lean_ctor_set_uint8(x_82, 0, x_69);
+lean_ctor_set_uint8(x_82, 1, x_70);
+lean_ctor_set_uint8(x_82, 2, x_71);
+lean_ctor_set_uint8(x_82, 3, x_72);
+lean_ctor_set_uint8(x_82, 4, x_73);
+lean_ctor_set_uint8(x_82, 5, x_74);
+lean_ctor_set_uint8(x_82, 6, x_75);
+lean_ctor_set_uint8(x_82, 7, x_76);
+lean_ctor_set_uint8(x_82, 8, x_77);
+lean_ctor_set_uint8(x_82, 9, x_78);
+x_83 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_83, 0, x_82);
+lean_ctor_set(x_83, 1, x_66);
+lean_ctor_set(x_83, 2, x_67);
+lean_ctor_set(x_83, 3, x_68);
+x_84 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_83, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_84) == 0)
 {
-lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-x_83 = lean_ctor_get(x_82, 0);
-lean_inc(x_83);
-x_84 = lean_ctor_get(x_82, 1);
-lean_inc(x_84);
-if (lean_is_exclusive(x_82)) {
- lean_ctor_release(x_82, 0);
- lean_ctor_release(x_82, 1);
- x_85 = x_82;
+lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; 
+x_85 = lean_ctor_get(x_84, 0);
+lean_inc(x_85);
+x_86 = lean_ctor_get(x_84, 1);
+lean_inc(x_86);
+if (lean_is_exclusive(x_84)) {
+ lean_ctor_release(x_84, 0);
+ lean_ctor_release(x_84, 1);
+ x_87 = x_84;
 } else {
- lean_dec_ref(x_82);
- x_85 = lean_box(0);
+ lean_dec_ref(x_84);
+ x_87 = lean_box(0);
 }
-if (lean_is_scalar(x_85)) {
- x_86 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_87)) {
+ x_88 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_86 = x_85;
+ x_88 = x_87;
 }
-lean_ctor_set(x_86, 0, x_83);
-lean_ctor_set(x_86, 1, x_84);
-return x_86;
+lean_ctor_set(x_88, 0, x_85);
+lean_ctor_set(x_88, 1, x_86);
+return x_88;
 }
 else
 {
-lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-x_87 = lean_ctor_get(x_82, 0);
-lean_inc(x_87);
-x_88 = lean_ctor_get(x_82, 1);
-lean_inc(x_88);
-if (lean_is_exclusive(x_82)) {
- lean_ctor_release(x_82, 0);
- lean_ctor_release(x_82, 1);
- x_89 = x_82;
+lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+x_89 = lean_ctor_get(x_84, 0);
+lean_inc(x_89);
+x_90 = lean_ctor_get(x_84, 1);
+lean_inc(x_90);
+if (lean_is_exclusive(x_84)) {
+ lean_ctor_release(x_84, 0);
+ lean_ctor_release(x_84, 1);
+ x_91 = x_84;
 } else {
- lean_dec_ref(x_82);
- x_89 = lean_box(0);
+ lean_dec_ref(x_84);
+ x_91 = lean_box(0);
 }
-if (lean_is_scalar(x_89)) {
- x_90 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_91)) {
+ x_92 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_90 = x_89;
+ x_92 = x_91;
 }
-lean_ctor_set(x_90, 0, x_87);
-lean_ctor_set(x_90, 1, x_88);
-return x_90;
+lean_ctor_set(x_92, 0, x_89);
+lean_ctor_set(x_92, 1, x_90);
+return x_92;
 }
 }
 else
 {
-lean_object* x_91; lean_object* x_92; lean_object* x_93; 
-if (lean_is_scalar(x_77)) {
- x_91 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+if (lean_is_scalar(x_79)) {
+ x_93 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_91 = x_77;
+ x_93 = x_79;
 }
-lean_ctor_set_uint8(x_91, 0, x_68);
-lean_ctor_set_uint8(x_91, 1, x_69);
-lean_ctor_set_uint8(x_91, 2, x_70);
-lean_ctor_set_uint8(x_91, 3, x_71);
-lean_ctor_set_uint8(x_91, 4, x_72);
-lean_ctor_set_uint8(x_91, 5, x_78);
-lean_ctor_set_uint8(x_91, 6, x_74);
-lean_ctor_set_uint8(x_91, 7, x_75);
-lean_ctor_set_uint8(x_91, 8, x_76);
-x_92 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_92, 0, x_91);
-lean_ctor_set(x_92, 1, x_65);
-lean_ctor_set(x_92, 2, x_66);
-lean_ctor_set(x_92, 3, x_67);
-x_93 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_92, x_5, x_6, x_7, x_8);
-if (lean_obj_tag(x_93) == 0)
+lean_ctor_set_uint8(x_93, 0, x_69);
+lean_ctor_set_uint8(x_93, 1, x_70);
+lean_ctor_set_uint8(x_93, 2, x_71);
+lean_ctor_set_uint8(x_93, 3, x_72);
+lean_ctor_set_uint8(x_93, 4, x_73);
+lean_ctor_set_uint8(x_93, 5, x_80);
+lean_ctor_set_uint8(x_93, 6, x_75);
+lean_ctor_set_uint8(x_93, 7, x_76);
+lean_ctor_set_uint8(x_93, 8, x_77);
+lean_ctor_set_uint8(x_93, 9, x_78);
+x_94 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_94, 0, x_93);
+lean_ctor_set(x_94, 1, x_66);
+lean_ctor_set(x_94, 2, x_67);
+lean_ctor_set(x_94, 3, x_68);
+x_95 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_94, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_95) == 0)
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; 
-x_94 = lean_ctor_get(x_93, 0);
-lean_inc(x_94);
-x_95 = lean_ctor_get(x_93, 1);
-lean_inc(x_95);
-if (lean_is_exclusive(x_93)) {
- lean_ctor_release(x_93, 0);
- lean_ctor_release(x_93, 1);
- x_96 = x_93;
+lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+x_96 = lean_ctor_get(x_95, 0);
+lean_inc(x_96);
+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_93);
- x_96 = lean_box(0);
+ lean_dec_ref(x_95);
+ x_98 = lean_box(0);
 }
-if (lean_is_scalar(x_96)) {
- x_97 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_98)) {
+ x_99 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_97 = x_96;
+ x_99 = x_98;
 }
-lean_ctor_set(x_97, 0, x_94);
-lean_ctor_set(x_97, 1, x_95);
-return x_97;
+lean_ctor_set(x_99, 0, x_96);
+lean_ctor_set(x_99, 1, x_97);
+return x_99;
 }
 else
 {
-lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-x_98 = lean_ctor_get(x_93, 0);
-lean_inc(x_98);
-x_99 = lean_ctor_get(x_93, 1);
-lean_inc(x_99);
-if (lean_is_exclusive(x_93)) {
- lean_ctor_release(x_93, 0);
- lean_ctor_release(x_93, 1);
- x_100 = x_93;
+lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
+x_100 = lean_ctor_get(x_95, 0);
+lean_inc(x_100);
+x_101 = lean_ctor_get(x_95, 1);
+lean_inc(x_101);
+if (lean_is_exclusive(x_95)) {
+ lean_ctor_release(x_95, 0);
+ lean_ctor_release(x_95, 1);
+ x_102 = x_95;
 } else {
- lean_dec_ref(x_93);
- x_100 = lean_box(0);
+ lean_dec_ref(x_95);
+ x_102 = lean_box(0);
 }
-if (lean_is_scalar(x_100)) {
- x_101 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_102)) {
+ x_103 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_101 = x_100;
+ x_103 = x_102;
 }
-lean_ctor_set(x_101, 0, x_98);
-lean_ctor_set(x_101, 1, x_99);
-return x_101;
+lean_ctor_set(x_103, 0, x_100);
+lean_ctor_set(x_103, 1, x_101);
+return x_103;
 }
 }
 }
@@ -5359,17 +5365,17 @@ x_21 = l_Lean_Expr_isMVar(x_1);
 x_22 = lean_st_ref_get(x_6, x_7);
 if (x_21 == 0)
 {
-uint8_t x_931; 
-x_931 = 1;
-x_23 = x_931;
-goto block_930;
+uint8_t x_935; 
+x_935 = 1;
+x_23 = x_935;
+goto block_934;
 }
 else
 {
-uint8_t x_932; 
-x_932 = 0;
-x_23 = x_932;
-goto block_930;
+uint8_t x_936; 
+x_936 = 0;
+x_23 = x_936;
+goto block_934;
 }
 block_20:
 {
@@ -5427,64 +5433,64 @@ return x_19;
 }
 }
 }
-block_930:
+block_934:
 {
 uint8_t x_24; 
 if (x_23 == 0)
 {
-uint8_t x_928; 
-x_928 = 0;
-x_24 = x_928;
-goto block_927;
+uint8_t x_932; 
+x_932 = 0;
+x_24 = x_932;
+goto block_931;
 }
 else
 {
-uint8_t x_929; 
-x_929 = 1;
-x_24 = x_929;
-goto block_927;
+uint8_t x_933; 
+x_933 = 1;
+x_24 = x_933;
+goto block_931;
 }
-block_927:
+block_931:
 {
-uint8_t x_25; lean_object* x_26; lean_object* x_916; lean_object* x_917; uint8_t x_918; 
-x_916 = lean_ctor_get(x_22, 0);
-lean_inc(x_916);
-x_917 = lean_ctor_get(x_916, 3);
-lean_inc(x_917);
-lean_dec(x_916);
-x_918 = lean_ctor_get_uint8(x_917, sizeof(void*)*1);
-lean_dec(x_917);
-if (x_918 == 0)
-{
-lean_object* x_919; uint8_t x_920; 
-x_919 = lean_ctor_get(x_22, 1);
-lean_inc(x_919);
-lean_dec(x_22);
-x_920 = 0;
-x_25 = x_920;
-x_26 = x_919;
-goto block_915;
-}
-else
-{
-lean_object* x_921; lean_object* x_922; lean_object* x_923; lean_object* x_924; lean_object* x_925; uint8_t x_926; 
-x_921 = lean_ctor_get(x_22, 1);
+uint8_t x_25; lean_object* x_26; lean_object* x_920; lean_object* x_921; uint8_t x_922; 
+x_920 = lean_ctor_get(x_22, 0);
+lean_inc(x_920);
+x_921 = lean_ctor_get(x_920, 3);
 lean_inc(x_921);
+lean_dec(x_920);
+x_922 = lean_ctor_get_uint8(x_921, sizeof(void*)*1);
+lean_dec(x_921);
+if (x_922 == 0)
+{
+lean_object* x_923; uint8_t x_924; 
+x_923 = lean_ctor_get(x_22, 1);
+lean_inc(x_923);
 lean_dec(x_22);
-x_922 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__4;
-x_923 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_922, x_3, x_4, x_5, x_6, x_921);
-x_924 = lean_ctor_get(x_923, 0);
-lean_inc(x_924);
-x_925 = lean_ctor_get(x_923, 1);
-lean_inc(x_925);
-lean_dec(x_923);
-x_926 = lean_unbox(x_924);
-lean_dec(x_924);
-x_25 = x_926;
-x_26 = x_925;
-goto block_915;
+x_924 = 0;
+x_25 = x_924;
+x_26 = x_923;
+goto block_919;
 }
-block_915:
+else
+{
+lean_object* x_925; lean_object* x_926; lean_object* x_927; lean_object* x_928; lean_object* x_929; uint8_t x_930; 
+x_925 = lean_ctor_get(x_22, 1);
+lean_inc(x_925);
+lean_dec(x_22);
+x_926 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__4;
+x_927 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_926, x_3, x_4, x_5, x_6, x_925);
+x_928 = lean_ctor_get(x_927, 0);
+lean_inc(x_928);
+x_929 = lean_ctor_get(x_927, 1);
+lean_inc(x_929);
+lean_dec(x_927);
+x_930 = lean_unbox(x_928);
+lean_dec(x_928);
+x_25 = x_930;
+x_26 = x_929;
+goto block_919;
+}
+block_919:
 {
 if (x_25 == 0)
 {
@@ -5828,7 +5834,7 @@ goto block_124;
 }
 else
 {
-uint8_t x_210; uint8_t x_211; uint8_t x_212; uint8_t x_213; uint8_t x_214; uint8_t x_215; uint8_t x_216; uint8_t x_217; uint8_t x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; 
+uint8_t x_210; uint8_t x_211; uint8_t x_212; uint8_t x_213; uint8_t x_214; uint8_t x_215; uint8_t x_216; uint8_t x_217; uint8_t x_218; uint8_t x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; 
 x_210 = lean_ctor_get_uint8(x_129, 0);
 x_211 = lean_ctor_get_uint8(x_129, 1);
 x_212 = lean_ctor_get_uint8(x_129, 2);
@@ -5837,82 +5843,84 @@ x_214 = lean_ctor_get_uint8(x_129, 4);
 x_215 = lean_ctor_get_uint8(x_129, 6);
 x_216 = lean_ctor_get_uint8(x_129, 7);
 x_217 = lean_ctor_get_uint8(x_129, 8);
+x_218 = lean_ctor_get_uint8(x_129, 9);
 lean_dec(x_129);
-x_218 = 1;
-x_219 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_219, 0, x_210);
-lean_ctor_set_uint8(x_219, 1, x_211);
-lean_ctor_set_uint8(x_219, 2, x_212);
-lean_ctor_set_uint8(x_219, 3, x_213);
-lean_ctor_set_uint8(x_219, 4, x_214);
-lean_ctor_set_uint8(x_219, 5, x_218);
-lean_ctor_set_uint8(x_219, 6, x_215);
-lean_ctor_set_uint8(x_219, 7, x_216);
-lean_ctor_set_uint8(x_219, 8, x_217);
-x_220 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_220, 0, x_219);
-lean_ctor_set(x_220, 1, x_132);
-lean_ctor_set(x_220, 2, x_133);
-lean_ctor_set(x_220, 3, x_134);
+x_219 = 1;
+x_220 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_220, 0, x_210);
+lean_ctor_set_uint8(x_220, 1, x_211);
+lean_ctor_set_uint8(x_220, 2, x_212);
+lean_ctor_set_uint8(x_220, 3, x_213);
+lean_ctor_set_uint8(x_220, 4, x_214);
+lean_ctor_set_uint8(x_220, 5, x_219);
+lean_ctor_set_uint8(x_220, 6, x_215);
+lean_ctor_set_uint8(x_220, 7, x_216);
+lean_ctor_set_uint8(x_220, 8, x_217);
+lean_ctor_set_uint8(x_220, 9, x_218);
+x_221 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_221, 0, x_220);
+lean_ctor_set(x_221, 1, x_132);
+lean_ctor_set(x_221, 2, x_133);
+lean_ctor_set(x_221, 3, x_134);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_130);
 lean_inc(x_126);
-x_221 = l_Lean_Meta_isExprDefEqAux(x_126, x_130, x_220, x_4, x_5, x_6, x_131);
-if (lean_obj_tag(x_221) == 0)
+x_222 = l_Lean_Meta_isExprDefEqAux(x_126, x_130, x_221, x_4, x_5, x_6, x_131);
+if (lean_obj_tag(x_222) == 0)
 {
-lean_object* x_222; uint8_t x_223; 
-x_222 = lean_ctor_get(x_221, 0);
-lean_inc(x_222);
-x_223 = lean_unbox(x_222);
+lean_object* x_223; uint8_t x_224; 
+x_223 = lean_ctor_get(x_222, 0);
+lean_inc(x_223);
+x_224 = lean_unbox(x_223);
+lean_dec(x_223);
+if (x_224 == 0)
+{
+lean_object* x_225; uint8_t x_226; lean_object* x_227; lean_object* x_247; lean_object* x_248; lean_object* x_249; uint8_t x_250; 
+x_225 = lean_ctor_get(x_222, 1);
+lean_inc(x_225);
 lean_dec(x_222);
-if (x_223 == 0)
-{
-lean_object* x_224; uint8_t x_225; lean_object* x_226; lean_object* x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
-x_224 = lean_ctor_get(x_221, 1);
-lean_inc(x_224);
-lean_dec(x_221);
-x_246 = lean_st_ref_get(x_6, x_224);
-x_247 = lean_ctor_get(x_246, 0);
-lean_inc(x_247);
-x_248 = lean_ctor_get(x_247, 3);
+x_247 = lean_st_ref_get(x_6, x_225);
+x_248 = lean_ctor_get(x_247, 0);
 lean_inc(x_248);
-lean_dec(x_247);
-x_249 = lean_ctor_get_uint8(x_248, sizeof(void*)*1);
+x_249 = lean_ctor_get(x_248, 3);
+lean_inc(x_249);
 lean_dec(x_248);
-if (x_249 == 0)
+x_250 = lean_ctor_get_uint8(x_249, sizeof(void*)*1);
+lean_dec(x_249);
+if (x_250 == 0)
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_246, 1);
-lean_inc(x_250);
-lean_dec(x_246);
-x_225 = x_39;
-x_226 = x_250;
-goto block_245;
-}
-else
-{
-lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; 
-x_251 = lean_ctor_get(x_246, 1);
+lean_object* x_251; 
+x_251 = lean_ctor_get(x_247, 1);
 lean_inc(x_251);
-lean_dec(x_246);
-x_252 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_253 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_252, x_3, x_4, x_5, x_6, x_251);
-x_254 = lean_ctor_get(x_253, 0);
-lean_inc(x_254);
-x_255 = lean_ctor_get(x_253, 1);
+lean_dec(x_247);
+x_226 = x_39;
+x_227 = x_251;
+goto block_246;
+}
+else
+{
+lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; uint8_t x_257; 
+x_252 = lean_ctor_get(x_247, 1);
+lean_inc(x_252);
+lean_dec(x_247);
+x_253 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_254 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_253, x_3, x_4, x_5, x_6, x_252);
+x_255 = lean_ctor_get(x_254, 0);
 lean_inc(x_255);
-lean_dec(x_253);
-x_256 = lean_unbox(x_254);
+x_256 = lean_ctor_get(x_254, 1);
+lean_inc(x_256);
 lean_dec(x_254);
-x_225 = x_256;
-x_226 = x_255;
-goto block_245;
+x_257 = lean_unbox(x_255);
+lean_dec(x_255);
+x_226 = x_257;
+x_227 = x_256;
+goto block_246;
 }
-block_245:
+block_246:
 {
-if (x_225 == 0)
+if (x_226 == 0)
 {
 lean_dec(x_130);
 lean_dec(x_126);
@@ -5922,165 +5930,165 @@ lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_42 = x_39;
-x_43 = x_226;
+x_43 = x_227;
 goto block_90;
 }
 else
 {
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; 
-x_227 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_227, 0, x_1);
-x_228 = l_Lean_KernelException_toMessageData___closed__15;
-x_229 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_229, 0, x_228);
-lean_ctor_set(x_229, 1, x_227);
-x_230 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
-x_231 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_231, 0, x_229);
-lean_ctor_set(x_231, 1, x_230);
-x_232 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_232, 0, x_126);
-x_233 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_233, 0, x_231);
-lean_ctor_set(x_233, 1, x_232);
-x_234 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_235 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_235, 0, x_233);
-lean_ctor_set(x_235, 1, x_234);
-x_236 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_236, 0, x_2);
-x_237 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_237, 0, x_235);
-lean_ctor_set(x_237, 1, x_236);
+lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; 
+x_228 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_228, 0, x_1);
+x_229 = l_Lean_KernelException_toMessageData___closed__15;
+x_230 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_230, 0, x_229);
+lean_ctor_set(x_230, 1, x_228);
+x_231 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
+x_232 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_232, 0, x_230);
+lean_ctor_set(x_232, 1, x_231);
+x_233 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_233, 0, x_126);
+x_234 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_234, 0, x_232);
+lean_ctor_set(x_234, 1, x_233);
+x_235 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_236 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_236, 0, x_234);
+lean_ctor_set(x_236, 1, x_235);
+x_237 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_237, 0, x_2);
 x_238 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_238, 0, x_237);
-lean_ctor_set(x_238, 1, x_230);
-x_239 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_239, 0, x_130);
-x_240 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_240, 0, x_238);
-lean_ctor_set(x_240, 1, x_239);
+lean_ctor_set(x_238, 0, x_236);
+lean_ctor_set(x_238, 1, x_237);
+x_239 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_239, 0, x_238);
+lean_ctor_set(x_239, 1, x_231);
+x_240 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_240, 0, x_130);
 x_241 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_241, 0, x_240);
-lean_ctor_set(x_241, 1, x_228);
-x_242 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_243 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_242, x_241, x_3, x_4, x_5, x_6, x_226);
+lean_ctor_set(x_241, 0, x_239);
+lean_ctor_set(x_241, 1, x_240);
+x_242 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_242, 0, x_241);
+lean_ctor_set(x_242, 1, x_229);
+x_243 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_244 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_243, x_242, x_3, x_4, x_5, x_6, x_227);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_244 = lean_ctor_get(x_243, 1);
-lean_inc(x_244);
-lean_dec(x_243);
+x_245 = lean_ctor_get(x_244, 1);
+lean_inc(x_245);
+lean_dec(x_244);
 x_42 = x_39;
-x_43 = x_244;
+x_43 = x_245;
 goto block_90;
 }
 }
 }
 else
 {
-lean_object* x_257; uint8_t x_258; lean_object* x_259; lean_object* x_280; lean_object* x_281; lean_object* x_282; uint8_t x_283; 
+lean_object* x_258; uint8_t x_259; lean_object* x_260; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; 
 lean_dec(x_130);
 lean_dec(x_126);
-x_257 = lean_ctor_get(x_221, 1);
-lean_inc(x_257);
-lean_dec(x_221);
-x_280 = lean_st_ref_get(x_6, x_257);
-x_281 = lean_ctor_get(x_280, 0);
-lean_inc(x_281);
-x_282 = lean_ctor_get(x_281, 3);
+x_258 = lean_ctor_get(x_222, 1);
+lean_inc(x_258);
+lean_dec(x_222);
+x_281 = lean_st_ref_get(x_6, x_258);
+x_282 = lean_ctor_get(x_281, 0);
 lean_inc(x_282);
-lean_dec(x_281);
-x_283 = lean_ctor_get_uint8(x_282, sizeof(void*)*1);
+x_283 = lean_ctor_get(x_282, 3);
+lean_inc(x_283);
 lean_dec(x_282);
-if (x_283 == 0)
+x_284 = lean_ctor_get_uint8(x_283, sizeof(void*)*1);
+lean_dec(x_283);
+if (x_284 == 0)
 {
-lean_object* x_284; 
-x_284 = lean_ctor_get(x_280, 1);
-lean_inc(x_284);
-lean_dec(x_280);
-x_258 = x_39;
-x_259 = x_284;
-goto block_279;
-}
-else
-{
-lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; uint8_t x_290; 
-x_285 = lean_ctor_get(x_280, 1);
+lean_object* x_285; 
+x_285 = lean_ctor_get(x_281, 1);
 lean_inc(x_285);
-lean_dec(x_280);
-x_286 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_287 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_286, x_3, x_4, x_5, x_6, x_285);
-x_288 = lean_ctor_get(x_287, 0);
-lean_inc(x_288);
-x_289 = lean_ctor_get(x_287, 1);
+lean_dec(x_281);
+x_259 = x_39;
+x_260 = x_285;
+goto block_280;
+}
+else
+{
+lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; uint8_t x_291; 
+x_286 = lean_ctor_get(x_281, 1);
+lean_inc(x_286);
+lean_dec(x_281);
+x_287 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_288 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_287, x_3, x_4, x_5, x_6, x_286);
+x_289 = lean_ctor_get(x_288, 0);
 lean_inc(x_289);
-lean_dec(x_287);
-x_290 = lean_unbox(x_288);
+x_290 = lean_ctor_get(x_288, 1);
+lean_inc(x_290);
 lean_dec(x_288);
-x_258 = x_290;
-x_259 = x_289;
-goto block_279;
+x_291 = lean_unbox(x_289);
+lean_dec(x_289);
+x_259 = x_291;
+x_260 = x_290;
+goto block_280;
 }
-block_279:
+block_280:
 {
-if (x_258 == 0)
+if (x_259 == 0)
 {
-lean_object* x_260; lean_object* x_261; lean_object* x_262; uint8_t x_263; 
-x_260 = l_Lean_Expr_mvarId_x21(x_1);
+lean_object* x_261; lean_object* x_262; lean_object* x_263; uint8_t x_264; 
+x_261 = l_Lean_Expr_mvarId_x21(x_1);
 lean_dec(x_1);
-x_261 = l_Lean_Meta_assignExprMVar(x_260, x_2, x_3, x_4, x_5, x_6, x_259);
+x_262 = l_Lean_Meta_assignExprMVar(x_261, x_2, x_3, x_4, x_5, x_6, x_260);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_262 = lean_ctor_get(x_261, 1);
-lean_inc(x_262);
-lean_dec(x_261);
-x_263 = 1;
-x_42 = x_263;
-x_43 = x_262;
+x_263 = lean_ctor_get(x_262, 1);
+lean_inc(x_263);
+lean_dec(x_262);
+x_264 = 1;
+x_42 = x_264;
+x_43 = x_263;
 goto block_90;
 }
 else
 {
-lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; 
+lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; uint8_t x_279; 
 lean_inc(x_1);
-x_264 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_264, 0, x_1);
-x_265 = l_Lean_KernelException_toMessageData___closed__15;
-x_266 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_266, 0, x_265);
-lean_ctor_set(x_266, 1, x_264);
-x_267 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_268 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_268, 0, x_266);
-lean_ctor_set(x_268, 1, x_267);
+x_265 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_265, 0, x_1);
+x_266 = l_Lean_KernelException_toMessageData___closed__15;
+x_267 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_267, 0, x_266);
+lean_ctor_set(x_267, 1, x_265);
+x_268 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_269 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_269, 0, x_267);
+lean_ctor_set(x_269, 1, x_268);
 lean_inc(x_2);
-x_269 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_269, 0, x_2);
-x_270 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_270, 0, x_268);
-lean_ctor_set(x_270, 1, x_269);
+x_270 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_270, 0, x_2);
 x_271 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_271, 0, x_270);
-lean_ctor_set(x_271, 1, x_265);
-x_272 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_273 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_272, x_271, x_3, x_4, x_5, x_6, x_259);
-x_274 = lean_ctor_get(x_273, 1);
-lean_inc(x_274);
-lean_dec(x_273);
-x_275 = l_Lean_Expr_mvarId_x21(x_1);
+lean_ctor_set(x_271, 0, x_269);
+lean_ctor_set(x_271, 1, x_270);
+x_272 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_272, 0, x_271);
+lean_ctor_set(x_272, 1, x_266);
+x_273 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_274 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_273, x_272, x_3, x_4, x_5, x_6, x_260);
+x_275 = lean_ctor_get(x_274, 1);
+lean_inc(x_275);
+lean_dec(x_274);
+x_276 = l_Lean_Expr_mvarId_x21(x_1);
 lean_dec(x_1);
-x_276 = l_Lean_Meta_assignExprMVar(x_275, x_2, x_3, x_4, x_5, x_6, x_274);
+x_277 = l_Lean_Meta_assignExprMVar(x_276, x_2, x_3, x_4, x_5, x_6, x_275);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_277 = lean_ctor_get(x_276, 1);
-lean_inc(x_277);
-lean_dec(x_276);
-x_278 = 1;
-x_42 = x_278;
-x_43 = x_277;
+x_278 = lean_ctor_get(x_277, 1);
+lean_inc(x_278);
+lean_dec(x_277);
+x_279 = 1;
+x_42 = x_279;
+x_43 = x_278;
 goto block_90;
 }
 }
@@ -6088,7 +6096,7 @@ goto block_90;
 }
 else
 {
-lean_object* x_291; lean_object* x_292; 
+lean_object* x_292; lean_object* x_293; 
 lean_dec(x_130);
 lean_dec(x_126);
 lean_dec(x_5);
@@ -6096,97 +6104,97 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_291 = lean_ctor_get(x_221, 0);
-lean_inc(x_291);
-x_292 = lean_ctor_get(x_221, 1);
+x_292 = lean_ctor_get(x_222, 0);
 lean_inc(x_292);
-lean_dec(x_221);
-x_91 = x_291;
-x_92 = x_292;
+x_293 = lean_ctor_get(x_222, 1);
+lean_inc(x_293);
+lean_dec(x_222);
+x_91 = x_292;
+x_92 = x_293;
 goto block_124;
 }
 }
 }
 else
 {
-lean_object* x_293; lean_object* x_294; 
+lean_object* x_294; lean_object* x_295; 
 lean_dec(x_126);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_293 = lean_ctor_get(x_128, 0);
-lean_inc(x_293);
-x_294 = lean_ctor_get(x_128, 1);
+x_294 = lean_ctor_get(x_128, 0);
 lean_inc(x_294);
+x_295 = lean_ctor_get(x_128, 1);
+lean_inc(x_295);
 lean_dec(x_128);
-x_91 = x_293;
-x_92 = x_294;
+x_91 = x_294;
+x_92 = x_295;
 goto block_124;
 }
 }
 else
 {
-lean_object* x_295; lean_object* x_296; 
+lean_object* x_296; lean_object* x_297; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_295 = lean_ctor_get(x_125, 0);
-lean_inc(x_295);
-x_296 = lean_ctor_get(x_125, 1);
+x_296 = lean_ctor_get(x_125, 0);
 lean_inc(x_296);
+x_297 = lean_ctor_get(x_125, 1);
+lean_inc(x_297);
 lean_dec(x_125);
-x_91 = x_295;
-x_92 = x_296;
+x_91 = x_296;
+x_92 = x_297;
 goto block_124;
 }
 }
 else
 {
-uint8_t x_297; lean_object* x_298; lean_object* x_312; lean_object* x_313; lean_object* x_314; uint8_t x_315; 
-x_312 = lean_st_ref_get(x_6, x_41);
-x_313 = lean_ctor_get(x_312, 0);
-lean_inc(x_313);
-x_314 = lean_ctor_get(x_313, 3);
+uint8_t x_298; lean_object* x_299; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_313 = lean_st_ref_get(x_6, x_41);
+x_314 = lean_ctor_get(x_313, 0);
 lean_inc(x_314);
-lean_dec(x_313);
-x_315 = lean_ctor_get_uint8(x_314, sizeof(void*)*1);
+x_315 = lean_ctor_get(x_314, 3);
+lean_inc(x_315);
 lean_dec(x_314);
-if (x_315 == 0)
+x_316 = lean_ctor_get_uint8(x_315, sizeof(void*)*1);
+lean_dec(x_315);
+if (x_316 == 0)
 {
-lean_object* x_316; 
-x_316 = lean_ctor_get(x_312, 1);
-lean_inc(x_316);
-lean_dec(x_312);
-x_297 = x_39;
-x_298 = x_316;
-goto block_311;
+lean_object* x_317; 
+x_317 = lean_ctor_get(x_313, 1);
+lean_inc(x_317);
+lean_dec(x_313);
+x_298 = x_39;
+x_299 = x_317;
+goto block_312;
 }
 else
 {
-lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; uint8_t x_322; 
-x_317 = lean_ctor_get(x_312, 1);
-lean_inc(x_317);
-lean_dec(x_312);
-x_318 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_319 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_318, x_3, x_4, x_5, x_6, x_317);
-x_320 = lean_ctor_get(x_319, 0);
-lean_inc(x_320);
-x_321 = lean_ctor_get(x_319, 1);
+lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; 
+x_318 = lean_ctor_get(x_313, 1);
+lean_inc(x_318);
+lean_dec(x_313);
+x_319 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_320 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_319, x_3, x_4, x_5, x_6, x_318);
+x_321 = lean_ctor_get(x_320, 0);
 lean_inc(x_321);
-lean_dec(x_319);
-x_322 = lean_unbox(x_320);
+x_322 = lean_ctor_get(x_320, 1);
+lean_inc(x_322);
 lean_dec(x_320);
-x_297 = x_322;
-x_298 = x_321;
-goto block_311;
+x_323 = lean_unbox(x_321);
+lean_dec(x_321);
+x_298 = x_323;
+x_299 = x_322;
+goto block_312;
 }
-block_311:
+block_312:
 {
-if (x_297 == 0)
+if (x_298 == 0)
 {
 lean_dec(x_5);
 lean_dec(x_4);
@@ -6194,41 +6202,41 @@ lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_42 = x_39;
-x_43 = x_298;
+x_43 = x_299;
 goto block_90;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; 
-x_299 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_299, 0, x_1);
-x_300 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
-x_301 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_301, 0, x_300);
-lean_ctor_set(x_301, 1, x_299);
-x_302 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_303 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_303, 0, x_301);
-lean_ctor_set(x_303, 1, x_302);
-x_304 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_304, 0, x_2);
-x_305 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_305, 0, x_303);
-lean_ctor_set(x_305, 1, x_304);
-x_306 = l_Lean_KernelException_toMessageData___closed__15;
-x_307 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_307, 0, x_305);
-lean_ctor_set(x_307, 1, x_306);
-x_308 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_309 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_308, x_307, x_3, x_4, x_5, x_6, x_298);
+lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; 
+x_300 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_300, 0, x_1);
+x_301 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
+x_302 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_302, 0, x_301);
+lean_ctor_set(x_302, 1, x_300);
+x_303 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_304 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_304, 0, x_302);
+lean_ctor_set(x_304, 1, x_303);
+x_305 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_305, 0, x_2);
+x_306 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_306, 0, x_304);
+lean_ctor_set(x_306, 1, x_305);
+x_307 = l_Lean_KernelException_toMessageData___closed__15;
+x_308 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_308, 0, x_306);
+lean_ctor_set(x_308, 1, x_307);
+x_309 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_310 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_309, x_308, x_3, x_4, x_5, x_6, x_299);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_310 = lean_ctor_get(x_309, 1);
-lean_inc(x_310);
-lean_dec(x_309);
+x_311 = lean_ctor_get(x_310, 1);
+lean_inc(x_311);
+lean_dec(x_310);
 x_42 = x_39;
-x_43 = x_310;
+x_43 = x_311;
 goto block_90;
 }
 }
@@ -6542,2052 +6550,2058 @@ goto block_20;
 }
 else
 {
-lean_object* x_323; uint8_t x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; uint8_t x_328; lean_object* x_329; lean_object* x_355; lean_object* x_356; 
-x_323 = lean_ctor_get(x_34, 0);
-lean_inc(x_323);
+lean_object* x_324; uint8_t x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; uint8_t x_329; lean_object* x_330; lean_object* x_356; lean_object* x_357; 
+x_324 = lean_ctor_get(x_34, 0);
+lean_inc(x_324);
 lean_dec(x_34);
-x_324 = 0;
-x_325 = lean_alloc_ctor(0, 1, 1);
-lean_ctor_set(x_325, 0, x_323);
-lean_ctor_set_uint8(x_325, sizeof(void*)*1, x_324);
-lean_ctor_set(x_33, 3, x_325);
-x_326 = lean_st_ref_set(x_6, x_33, x_35);
-x_327 = lean_ctor_get(x_326, 1);
-lean_inc(x_327);
-lean_dec(x_326);
+x_325 = 0;
+x_326 = lean_alloc_ctor(0, 1, 1);
+lean_ctor_set(x_326, 0, x_324);
+lean_ctor_set_uint8(x_326, sizeof(void*)*1, x_325);
+lean_ctor_set(x_33, 3, x_326);
+x_327 = lean_st_ref_set(x_6, x_33, x_35);
+x_328 = lean_ctor_get(x_327, 1);
+lean_inc(x_328);
+lean_dec(x_327);
 if (x_24 == 0)
 {
-lean_object* x_376; 
+lean_object* x_377; 
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_1);
-x_376 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_327);
-if (lean_obj_tag(x_376) == 0)
+x_377 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_328);
+if (lean_obj_tag(x_377) == 0)
 {
-lean_object* x_377; lean_object* x_378; lean_object* x_379; 
-x_377 = lean_ctor_get(x_376, 0);
-lean_inc(x_377);
-x_378 = lean_ctor_get(x_376, 1);
+lean_object* x_378; lean_object* x_379; lean_object* x_380; 
+x_378 = lean_ctor_get(x_377, 0);
 lean_inc(x_378);
-lean_dec(x_376);
+x_379 = lean_ctor_get(x_377, 1);
+lean_inc(x_379);
+lean_dec(x_377);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-x_379 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_378);
-if (lean_obj_tag(x_379) == 0)
+x_380 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_379);
+if (lean_obj_tag(x_380) == 0)
 {
-lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; uint8_t x_386; uint8_t x_387; uint8_t x_388; uint8_t x_389; uint8_t x_390; uint8_t x_391; uint8_t x_392; uint8_t x_393; lean_object* x_394; uint8_t x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; 
-x_380 = lean_ctor_get(x_3, 0);
-lean_inc(x_380);
-x_381 = lean_ctor_get(x_379, 0);
+lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; uint8_t x_387; uint8_t x_388; uint8_t x_389; uint8_t x_390; uint8_t x_391; uint8_t x_392; uint8_t x_393; uint8_t x_394; uint8_t x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; 
+x_381 = lean_ctor_get(x_3, 0);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_379, 1);
+x_382 = lean_ctor_get(x_380, 0);
 lean_inc(x_382);
-lean_dec(x_379);
-x_383 = lean_ctor_get(x_3, 1);
+x_383 = lean_ctor_get(x_380, 1);
 lean_inc(x_383);
-x_384 = lean_ctor_get(x_3, 2);
+lean_dec(x_380);
+x_384 = lean_ctor_get(x_3, 1);
 lean_inc(x_384);
-x_385 = lean_ctor_get(x_3, 3);
+x_385 = lean_ctor_get(x_3, 2);
 lean_inc(x_385);
-x_386 = lean_ctor_get_uint8(x_380, 0);
-x_387 = lean_ctor_get_uint8(x_380, 1);
-x_388 = lean_ctor_get_uint8(x_380, 2);
-x_389 = lean_ctor_get_uint8(x_380, 3);
-x_390 = lean_ctor_get_uint8(x_380, 4);
-x_391 = lean_ctor_get_uint8(x_380, 6);
-x_392 = lean_ctor_get_uint8(x_380, 7);
-x_393 = lean_ctor_get_uint8(x_380, 8);
-if (lean_is_exclusive(x_380)) {
- x_394 = x_380;
+x_386 = lean_ctor_get(x_3, 3);
+lean_inc(x_386);
+x_387 = lean_ctor_get_uint8(x_381, 0);
+x_388 = lean_ctor_get_uint8(x_381, 1);
+x_389 = lean_ctor_get_uint8(x_381, 2);
+x_390 = lean_ctor_get_uint8(x_381, 3);
+x_391 = lean_ctor_get_uint8(x_381, 4);
+x_392 = lean_ctor_get_uint8(x_381, 6);
+x_393 = lean_ctor_get_uint8(x_381, 7);
+x_394 = lean_ctor_get_uint8(x_381, 8);
+x_395 = lean_ctor_get_uint8(x_381, 9);
+if (lean_is_exclusive(x_381)) {
+ x_396 = x_381;
 } else {
- lean_dec_ref(x_380);
- x_394 = lean_box(0);
+ lean_dec_ref(x_381);
+ x_396 = lean_box(0);
 }
-x_395 = 1;
-if (lean_is_scalar(x_394)) {
- x_396 = lean_alloc_ctor(0, 0, 9);
+x_397 = 1;
+if (lean_is_scalar(x_396)) {
+ x_398 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_396 = x_394;
+ x_398 = x_396;
 }
-lean_ctor_set_uint8(x_396, 0, x_386);
-lean_ctor_set_uint8(x_396, 1, x_387);
-lean_ctor_set_uint8(x_396, 2, x_388);
-lean_ctor_set_uint8(x_396, 3, x_389);
-lean_ctor_set_uint8(x_396, 4, x_390);
-lean_ctor_set_uint8(x_396, 5, x_395);
-lean_ctor_set_uint8(x_396, 6, x_391);
-lean_ctor_set_uint8(x_396, 7, x_392);
-lean_ctor_set_uint8(x_396, 8, x_393);
-x_397 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_397, 0, x_396);
-lean_ctor_set(x_397, 1, x_383);
-lean_ctor_set(x_397, 2, x_384);
-lean_ctor_set(x_397, 3, x_385);
+lean_ctor_set_uint8(x_398, 0, x_387);
+lean_ctor_set_uint8(x_398, 1, x_388);
+lean_ctor_set_uint8(x_398, 2, x_389);
+lean_ctor_set_uint8(x_398, 3, x_390);
+lean_ctor_set_uint8(x_398, 4, x_391);
+lean_ctor_set_uint8(x_398, 5, x_397);
+lean_ctor_set_uint8(x_398, 6, x_392);
+lean_ctor_set_uint8(x_398, 7, x_393);
+lean_ctor_set_uint8(x_398, 8, x_394);
+lean_ctor_set_uint8(x_398, 9, x_395);
+x_399 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_399, 0, x_398);
+lean_ctor_set(x_399, 1, x_384);
+lean_ctor_set(x_399, 2, x_385);
+lean_ctor_set(x_399, 3, x_386);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_381);
-lean_inc(x_377);
-x_398 = l_Lean_Meta_isExprDefEqAux(x_377, x_381, x_397, x_4, x_5, x_6, x_382);
-if (lean_obj_tag(x_398) == 0)
+lean_inc(x_382);
+lean_inc(x_378);
+x_400 = l_Lean_Meta_isExprDefEqAux(x_378, x_382, x_399, x_4, x_5, x_6, x_383);
+if (lean_obj_tag(x_400) == 0)
 {
-lean_object* x_399; uint8_t x_400; 
-x_399 = lean_ctor_get(x_398, 0);
-lean_inc(x_399);
-x_400 = lean_unbox(x_399);
-lean_dec(x_399);
-if (x_400 == 0)
-{
-lean_object* x_401; uint8_t x_402; lean_object* x_403; lean_object* x_423; lean_object* x_424; lean_object* x_425; uint8_t x_426; 
-x_401 = lean_ctor_get(x_398, 1);
+lean_object* x_401; uint8_t x_402; 
+x_401 = lean_ctor_get(x_400, 0);
 lean_inc(x_401);
-lean_dec(x_398);
-x_423 = lean_st_ref_get(x_6, x_401);
-x_424 = lean_ctor_get(x_423, 0);
-lean_inc(x_424);
-x_425 = lean_ctor_get(x_424, 3);
-lean_inc(x_425);
-lean_dec(x_424);
-x_426 = lean_ctor_get_uint8(x_425, sizeof(void*)*1);
-lean_dec(x_425);
-if (x_426 == 0)
+x_402 = lean_unbox(x_401);
+lean_dec(x_401);
+if (x_402 == 0)
 {
-lean_object* x_427; 
-x_427 = lean_ctor_get(x_423, 1);
+lean_object* x_403; uint8_t x_404; lean_object* x_405; lean_object* x_425; lean_object* x_426; lean_object* x_427; uint8_t x_428; 
+x_403 = lean_ctor_get(x_400, 1);
+lean_inc(x_403);
+lean_dec(x_400);
+x_425 = lean_st_ref_get(x_6, x_403);
+x_426 = lean_ctor_get(x_425, 0);
+lean_inc(x_426);
+x_427 = lean_ctor_get(x_426, 3);
 lean_inc(x_427);
-lean_dec(x_423);
-x_402 = x_324;
-x_403 = x_427;
-goto block_422;
+lean_dec(x_426);
+x_428 = lean_ctor_get_uint8(x_427, sizeof(void*)*1);
+lean_dec(x_427);
+if (x_428 == 0)
+{
+lean_object* x_429; 
+x_429 = lean_ctor_get(x_425, 1);
+lean_inc(x_429);
+lean_dec(x_425);
+x_404 = x_325;
+x_405 = x_429;
+goto block_424;
 }
 else
 {
-lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; uint8_t x_433; 
-x_428 = lean_ctor_get(x_423, 1);
-lean_inc(x_428);
-lean_dec(x_423);
-x_429 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_430 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_429, x_3, x_4, x_5, x_6, x_428);
-x_431 = lean_ctor_get(x_430, 0);
-lean_inc(x_431);
-x_432 = lean_ctor_get(x_430, 1);
-lean_inc(x_432);
-lean_dec(x_430);
-x_433 = lean_unbox(x_431);
-lean_dec(x_431);
-x_402 = x_433;
-x_403 = x_432;
-goto block_422;
+lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; uint8_t x_435; 
+x_430 = lean_ctor_get(x_425, 1);
+lean_inc(x_430);
+lean_dec(x_425);
+x_431 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_432 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_431, x_3, x_4, x_5, x_6, x_430);
+x_433 = lean_ctor_get(x_432, 0);
+lean_inc(x_433);
+x_434 = lean_ctor_get(x_432, 1);
+lean_inc(x_434);
+lean_dec(x_432);
+x_435 = lean_unbox(x_433);
+lean_dec(x_433);
+x_404 = x_435;
+x_405 = x_434;
+goto block_424;
 }
-block_422:
+block_424:
 {
-if (x_402 == 0)
+if (x_404 == 0)
 {
-lean_dec(x_381);
-lean_dec(x_377);
+lean_dec(x_382);
+lean_dec(x_378);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_328 = x_324;
-x_329 = x_403;
-goto block_354;
+x_329 = x_325;
+x_330 = x_405;
+goto block_355;
 }
 else
 {
-lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; 
-x_404 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_404, 0, x_1);
-x_405 = l_Lean_KernelException_toMessageData___closed__15;
-x_406 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_406, 0, x_405);
-lean_ctor_set(x_406, 1, x_404);
-x_407 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
+lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; lean_object* x_422; lean_object* x_423; 
+x_406 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_406, 0, x_1);
+x_407 = l_Lean_KernelException_toMessageData___closed__15;
 x_408 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_408, 0, x_406);
-lean_ctor_set(x_408, 1, x_407);
-x_409 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_409, 0, x_377);
+lean_ctor_set(x_408, 0, x_407);
+lean_ctor_set(x_408, 1, x_406);
+x_409 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
 x_410 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_410, 0, x_408);
 lean_ctor_set(x_410, 1, x_409);
-x_411 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_411 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_411, 0, x_378);
 x_412 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_412, 0, x_410);
 lean_ctor_set(x_412, 1, x_411);
-x_413 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_413, 0, x_2);
+x_413 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
 x_414 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_414, 0, x_412);
 lean_ctor_set(x_414, 1, x_413);
-x_415 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_415, 0, x_414);
-lean_ctor_set(x_415, 1, x_407);
-x_416 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_416, 0, x_381);
+x_415 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_415, 0, x_2);
+x_416 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_416, 0, x_414);
+lean_ctor_set(x_416, 1, x_415);
 x_417 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_417, 0, x_415);
-lean_ctor_set(x_417, 1, x_416);
-x_418 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_418, 0, x_417);
-lean_ctor_set(x_418, 1, x_405);
-x_419 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_420 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_419, x_418, x_3, x_4, x_5, x_6, x_403);
+lean_ctor_set(x_417, 0, x_416);
+lean_ctor_set(x_417, 1, x_409);
+x_418 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_418, 0, x_382);
+x_419 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_419, 0, x_417);
+lean_ctor_set(x_419, 1, x_418);
+x_420 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_420, 0, x_419);
+lean_ctor_set(x_420, 1, x_407);
+x_421 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_422 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_421, x_420, x_3, x_4, x_5, x_6, x_405);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_421 = lean_ctor_get(x_420, 1);
-lean_inc(x_421);
-lean_dec(x_420);
-x_328 = x_324;
-x_329 = x_421;
-goto block_354;
+x_423 = lean_ctor_get(x_422, 1);
+lean_inc(x_423);
+lean_dec(x_422);
+x_329 = x_325;
+x_330 = x_423;
+goto block_355;
 }
 }
 }
 else
 {
-lean_object* x_434; uint8_t x_435; lean_object* x_436; lean_object* x_457; lean_object* x_458; lean_object* x_459; uint8_t x_460; 
-lean_dec(x_381);
-lean_dec(x_377);
-x_434 = lean_ctor_get(x_398, 1);
-lean_inc(x_434);
-lean_dec(x_398);
-x_457 = lean_st_ref_get(x_6, x_434);
-x_458 = lean_ctor_get(x_457, 0);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_458, 3);
-lean_inc(x_459);
-lean_dec(x_458);
-x_460 = lean_ctor_get_uint8(x_459, sizeof(void*)*1);
-lean_dec(x_459);
-if (x_460 == 0)
-{
-lean_object* x_461; 
-x_461 = lean_ctor_get(x_457, 1);
+lean_object* x_436; uint8_t x_437; lean_object* x_438; lean_object* x_459; lean_object* x_460; lean_object* x_461; uint8_t x_462; 
+lean_dec(x_382);
+lean_dec(x_378);
+x_436 = lean_ctor_get(x_400, 1);
+lean_inc(x_436);
+lean_dec(x_400);
+x_459 = lean_st_ref_get(x_6, x_436);
+x_460 = lean_ctor_get(x_459, 0);
+lean_inc(x_460);
+x_461 = lean_ctor_get(x_460, 3);
 lean_inc(x_461);
-lean_dec(x_457);
-x_435 = x_324;
-x_436 = x_461;
-goto block_456;
+lean_dec(x_460);
+x_462 = lean_ctor_get_uint8(x_461, sizeof(void*)*1);
+lean_dec(x_461);
+if (x_462 == 0)
+{
+lean_object* x_463; 
+x_463 = lean_ctor_get(x_459, 1);
+lean_inc(x_463);
+lean_dec(x_459);
+x_437 = x_325;
+x_438 = x_463;
+goto block_458;
 }
 else
 {
-lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; uint8_t x_467; 
-x_462 = lean_ctor_get(x_457, 1);
-lean_inc(x_462);
-lean_dec(x_457);
-x_463 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_464 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_463, x_3, x_4, x_5, x_6, x_462);
-x_465 = lean_ctor_get(x_464, 0);
-lean_inc(x_465);
-x_466 = lean_ctor_get(x_464, 1);
-lean_inc(x_466);
-lean_dec(x_464);
-x_467 = lean_unbox(x_465);
-lean_dec(x_465);
-x_435 = x_467;
-x_436 = x_466;
-goto block_456;
+lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; 
+x_464 = lean_ctor_get(x_459, 1);
+lean_inc(x_464);
+lean_dec(x_459);
+x_465 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_466 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_465, x_3, x_4, x_5, x_6, x_464);
+x_467 = lean_ctor_get(x_466, 0);
+lean_inc(x_467);
+x_468 = lean_ctor_get(x_466, 1);
+lean_inc(x_468);
+lean_dec(x_466);
+x_469 = lean_unbox(x_467);
+lean_dec(x_467);
+x_437 = x_469;
+x_438 = x_468;
+goto block_458;
 }
-block_456:
+block_458:
 {
-if (x_435 == 0)
+if (x_437 == 0)
 {
-lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; 
-x_437 = l_Lean_Expr_mvarId_x21(x_1);
+lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; 
+x_439 = l_Lean_Expr_mvarId_x21(x_1);
 lean_dec(x_1);
-x_438 = l_Lean_Meta_assignExprMVar(x_437, x_2, x_3, x_4, x_5, x_6, x_436);
+x_440 = l_Lean_Meta_assignExprMVar(x_439, x_2, x_3, x_4, x_5, x_6, x_438);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_439 = lean_ctor_get(x_438, 1);
-lean_inc(x_439);
-lean_dec(x_438);
-x_440 = 1;
-x_328 = x_440;
-x_329 = x_439;
-goto block_354;
+x_441 = lean_ctor_get(x_440, 1);
+lean_inc(x_441);
+lean_dec(x_440);
+x_442 = 1;
+x_329 = x_442;
+x_330 = x_441;
+goto block_355;
 }
 else
 {
-lean_object* x_441; lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; 
+lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; uint8_t x_457; 
 lean_inc(x_1);
-x_441 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_441, 0, x_1);
-x_442 = l_Lean_KernelException_toMessageData___closed__15;
-x_443 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_443, 0, x_442);
-lean_ctor_set(x_443, 1, x_441);
-x_444 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_443 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_443, 0, x_1);
+x_444 = l_Lean_KernelException_toMessageData___closed__15;
 x_445 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_444);
-lean_inc(x_2);
-x_446 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_446, 0, x_2);
+lean_ctor_set(x_445, 0, x_444);
+lean_ctor_set(x_445, 1, x_443);
+x_446 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
 x_447 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_447, 0, x_445);
 lean_ctor_set(x_447, 1, x_446);
-x_448 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_448, 0, x_447);
-lean_ctor_set(x_448, 1, x_442);
-x_449 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_450 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_449, x_448, x_3, x_4, x_5, x_6, x_436);
-x_451 = lean_ctor_get(x_450, 1);
-lean_inc(x_451);
-lean_dec(x_450);
-x_452 = l_Lean_Expr_mvarId_x21(x_1);
+lean_inc(x_2);
+x_448 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_448, 0, x_2);
+x_449 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_449, 0, x_447);
+lean_ctor_set(x_449, 1, x_448);
+x_450 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_450, 0, x_449);
+lean_ctor_set(x_450, 1, x_444);
+x_451 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_452 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_451, x_450, x_3, x_4, x_5, x_6, x_438);
+x_453 = lean_ctor_get(x_452, 1);
+lean_inc(x_453);
+lean_dec(x_452);
+x_454 = l_Lean_Expr_mvarId_x21(x_1);
 lean_dec(x_1);
-x_453 = l_Lean_Meta_assignExprMVar(x_452, x_2, x_3, x_4, x_5, x_6, x_451);
+x_455 = l_Lean_Meta_assignExprMVar(x_454, x_2, x_3, x_4, x_5, x_6, x_453);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_454 = lean_ctor_get(x_453, 1);
-lean_inc(x_454);
-lean_dec(x_453);
-x_455 = 1;
-x_328 = x_455;
-x_329 = x_454;
-goto block_354;
+x_456 = lean_ctor_get(x_455, 1);
+lean_inc(x_456);
+lean_dec(x_455);
+x_457 = 1;
+x_329 = x_457;
+x_330 = x_456;
+goto block_355;
 }
 }
 }
 }
 else
 {
-lean_object* x_468; lean_object* x_469; 
-lean_dec(x_381);
-lean_dec(x_377);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-x_468 = lean_ctor_get(x_398, 0);
-lean_inc(x_468);
-x_469 = lean_ctor_get(x_398, 1);
-lean_inc(x_469);
-lean_dec(x_398);
-x_355 = x_468;
-x_356 = x_469;
-goto block_375;
-}
-}
-else
-{
 lean_object* x_470; lean_object* x_471; 
-lean_dec(x_377);
+lean_dec(x_382);
+lean_dec(x_378);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_470 = lean_ctor_get(x_379, 0);
+x_470 = lean_ctor_get(x_400, 0);
 lean_inc(x_470);
-x_471 = lean_ctor_get(x_379, 1);
+x_471 = lean_ctor_get(x_400, 1);
 lean_inc(x_471);
-lean_dec(x_379);
-x_355 = x_470;
-x_356 = x_471;
-goto block_375;
+lean_dec(x_400);
+x_356 = x_470;
+x_357 = x_471;
+goto block_376;
 }
 }
 else
 {
 lean_object* x_472; lean_object* x_473; 
+lean_dec(x_378);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_472 = lean_ctor_get(x_376, 0);
+x_472 = lean_ctor_get(x_380, 0);
 lean_inc(x_472);
-x_473 = lean_ctor_get(x_376, 1);
+x_473 = lean_ctor_get(x_380, 1);
 lean_inc(x_473);
-lean_dec(x_376);
-x_355 = x_472;
-x_356 = x_473;
-goto block_375;
+lean_dec(x_380);
+x_356 = x_472;
+x_357 = x_473;
+goto block_376;
 }
 }
 else
 {
-uint8_t x_474; lean_object* x_475; lean_object* x_489; lean_object* x_490; lean_object* x_491; uint8_t x_492; 
-x_489 = lean_st_ref_get(x_6, x_327);
-x_490 = lean_ctor_get(x_489, 0);
-lean_inc(x_490);
-x_491 = lean_ctor_get(x_490, 3);
-lean_inc(x_491);
-lean_dec(x_490);
-x_492 = lean_ctor_get_uint8(x_491, sizeof(void*)*1);
-lean_dec(x_491);
-if (x_492 == 0)
+lean_object* x_474; lean_object* x_475; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_474 = lean_ctor_get(x_377, 0);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_377, 1);
+lean_inc(x_475);
+lean_dec(x_377);
+x_356 = x_474;
+x_357 = x_475;
+goto block_376;
+}
+}
+else
 {
-lean_object* x_493; 
-x_493 = lean_ctor_get(x_489, 1);
+uint8_t x_476; lean_object* x_477; lean_object* x_491; lean_object* x_492; lean_object* x_493; uint8_t x_494; 
+x_491 = lean_st_ref_get(x_6, x_328);
+x_492 = lean_ctor_get(x_491, 0);
+lean_inc(x_492);
+x_493 = lean_ctor_get(x_492, 3);
 lean_inc(x_493);
-lean_dec(x_489);
-x_474 = x_324;
-x_475 = x_493;
-goto block_488;
+lean_dec(x_492);
+x_494 = lean_ctor_get_uint8(x_493, sizeof(void*)*1);
+lean_dec(x_493);
+if (x_494 == 0)
+{
+lean_object* x_495; 
+x_495 = lean_ctor_get(x_491, 1);
+lean_inc(x_495);
+lean_dec(x_491);
+x_476 = x_325;
+x_477 = x_495;
+goto block_490;
 }
 else
 {
-lean_object* x_494; lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; uint8_t x_499; 
-x_494 = lean_ctor_get(x_489, 1);
-lean_inc(x_494);
-lean_dec(x_489);
-x_495 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_496 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_495, x_3, x_4, x_5, x_6, x_494);
-x_497 = lean_ctor_get(x_496, 0);
-lean_inc(x_497);
-x_498 = lean_ctor_get(x_496, 1);
-lean_inc(x_498);
-lean_dec(x_496);
-x_499 = lean_unbox(x_497);
-lean_dec(x_497);
-x_474 = x_499;
-x_475 = x_498;
-goto block_488;
+lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; uint8_t x_501; 
+x_496 = lean_ctor_get(x_491, 1);
+lean_inc(x_496);
+lean_dec(x_491);
+x_497 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_498 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_497, x_3, x_4, x_5, x_6, x_496);
+x_499 = lean_ctor_get(x_498, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_498, 1);
+lean_inc(x_500);
+lean_dec(x_498);
+x_501 = lean_unbox(x_499);
+lean_dec(x_499);
+x_476 = x_501;
+x_477 = x_500;
+goto block_490;
 }
-block_488:
+block_490:
 {
-if (x_474 == 0)
+if (x_476 == 0)
 {
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_328 = x_324;
-x_329 = x_475;
-goto block_354;
+x_329 = x_325;
+x_330 = x_477;
+goto block_355;
 }
 else
 {
-lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; 
-x_476 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_476, 0, x_1);
-x_477 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
-x_478 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_478, 0, x_477);
-lean_ctor_set(x_478, 1, x_476);
-x_479 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; 
+x_478 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_478, 0, x_1);
+x_479 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
 x_480 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_480, 0, x_478);
-lean_ctor_set(x_480, 1, x_479);
-x_481 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_481, 0, x_2);
+lean_ctor_set(x_480, 0, x_479);
+lean_ctor_set(x_480, 1, x_478);
+x_481 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
 x_482 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_482, 0, x_480);
 lean_ctor_set(x_482, 1, x_481);
-x_483 = l_Lean_KernelException_toMessageData___closed__15;
+x_483 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_483, 0, x_2);
 x_484 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_484, 0, x_482);
 lean_ctor_set(x_484, 1, x_483);
-x_485 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_486 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_485, x_484, x_3, x_4, x_5, x_6, x_475);
+x_485 = l_Lean_KernelException_toMessageData___closed__15;
+x_486 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_486, 0, x_484);
+lean_ctor_set(x_486, 1, x_485);
+x_487 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_488 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_487, x_486, x_3, x_4, x_5, x_6, x_477);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_487 = lean_ctor_get(x_486, 1);
-lean_inc(x_487);
-lean_dec(x_486);
-x_328 = x_324;
-x_329 = x_487;
-goto block_354;
+x_489 = lean_ctor_get(x_488, 1);
+lean_inc(x_489);
+lean_dec(x_488);
+x_329 = x_325;
+x_330 = x_489;
+goto block_355;
 }
 }
 }
-block_354:
+block_355:
 {
-lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; uint8_t x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; 
-x_330 = lean_st_ref_get(x_6, x_329);
-x_331 = lean_ctor_get(x_330, 0);
-lean_inc(x_331);
-x_332 = lean_ctor_get(x_330, 1);
+lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; 
+x_331 = lean_st_ref_get(x_6, x_330);
+x_332 = lean_ctor_get(x_331, 0);
 lean_inc(x_332);
-lean_dec(x_330);
-x_333 = lean_ctor_get(x_331, 3);
+x_333 = lean_ctor_get(x_331, 1);
 lean_inc(x_333);
 lean_dec(x_331);
-x_334 = lean_ctor_get_uint8(x_333, sizeof(void*)*1);
-lean_dec(x_333);
-x_335 = lean_st_ref_take(x_6, x_332);
-x_336 = lean_ctor_get(x_335, 0);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_336, 3);
+x_334 = lean_ctor_get(x_332, 3);
+lean_inc(x_334);
+lean_dec(x_332);
+x_335 = lean_ctor_get_uint8(x_334, sizeof(void*)*1);
+lean_dec(x_334);
+x_336 = lean_st_ref_take(x_6, x_333);
+x_337 = lean_ctor_get(x_336, 0);
 lean_inc(x_337);
-x_338 = lean_ctor_get(x_335, 1);
+x_338 = lean_ctor_get(x_337, 3);
 lean_inc(x_338);
-lean_dec(x_335);
-x_339 = lean_ctor_get(x_336, 0);
+x_339 = lean_ctor_get(x_336, 1);
 lean_inc(x_339);
-x_340 = lean_ctor_get(x_336, 1);
+lean_dec(x_336);
+x_340 = lean_ctor_get(x_337, 0);
 lean_inc(x_340);
-x_341 = lean_ctor_get(x_336, 2);
+x_341 = lean_ctor_get(x_337, 1);
 lean_inc(x_341);
-if (lean_is_exclusive(x_336)) {
- lean_ctor_release(x_336, 0);
- lean_ctor_release(x_336, 1);
- lean_ctor_release(x_336, 2);
- lean_ctor_release(x_336, 3);
- x_342 = x_336;
-} else {
- lean_dec_ref(x_336);
- x_342 = lean_box(0);
-}
-x_343 = lean_ctor_get(x_337, 0);
-lean_inc(x_343);
+x_342 = lean_ctor_get(x_337, 2);
+lean_inc(x_342);
 if (lean_is_exclusive(x_337)) {
  lean_ctor_release(x_337, 0);
- x_344 = x_337;
+ lean_ctor_release(x_337, 1);
+ lean_ctor_release(x_337, 2);
+ lean_ctor_release(x_337, 3);
+ x_343 = x_337;
 } else {
  lean_dec_ref(x_337);
- x_344 = lean_box(0);
+ x_343 = lean_box(0);
 }
-if (lean_is_scalar(x_344)) {
- x_345 = lean_alloc_ctor(0, 1, 1);
+x_344 = lean_ctor_get(x_338, 0);
+lean_inc(x_344);
+if (lean_is_exclusive(x_338)) {
+ lean_ctor_release(x_338, 0);
+ x_345 = x_338;
 } else {
- x_345 = x_344;
+ lean_dec_ref(x_338);
+ x_345 = lean_box(0);
 }
-lean_ctor_set(x_345, 0, x_343);
-lean_ctor_set_uint8(x_345, sizeof(void*)*1, x_31);
-if (lean_is_scalar(x_342)) {
- x_346 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_345)) {
+ x_346 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_346 = x_342;
+ x_346 = x_345;
 }
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_345);
-x_347 = lean_st_ref_set(x_6, x_346, x_338);
+lean_ctor_set(x_346, 0, x_344);
+lean_ctor_set_uint8(x_346, sizeof(void*)*1, x_31);
+if (lean_is_scalar(x_343)) {
+ x_347 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_347 = x_343;
+}
+lean_ctor_set(x_347, 0, x_340);
+lean_ctor_set(x_347, 1, x_341);
+lean_ctor_set(x_347, 2, x_342);
+lean_ctor_set(x_347, 3, x_346);
+x_348 = lean_st_ref_set(x_6, x_347, x_339);
 lean_dec(x_6);
-x_348 = lean_ctor_get(x_347, 1);
-lean_inc(x_348);
-if (lean_is_exclusive(x_347)) {
- lean_ctor_release(x_347, 0);
- lean_ctor_release(x_347, 1);
- x_349 = x_347;
+x_349 = lean_ctor_get(x_348, 1);
+lean_inc(x_349);
+if (lean_is_exclusive(x_348)) {
+ lean_ctor_release(x_348, 0);
+ lean_ctor_release(x_348, 1);
+ x_350 = x_348;
 } else {
- lean_dec_ref(x_347);
- x_349 = lean_box(0);
+ lean_dec_ref(x_348);
+ x_350 = lean_box(0);
 }
-x_350 = lean_box(x_328);
-x_351 = lean_box(x_334);
-x_352 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_352, 0, x_350);
-lean_ctor_set(x_352, 1, x_351);
-if (lean_is_scalar(x_349)) {
- x_353 = lean_alloc_ctor(0, 2, 0);
+x_351 = lean_box(x_329);
+x_352 = lean_box(x_335);
+x_353 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_353, 0, x_351);
+lean_ctor_set(x_353, 1, x_352);
+if (lean_is_scalar(x_350)) {
+ x_354 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_353 = x_349;
+ x_354 = x_350;
 }
-lean_ctor_set(x_353, 0, x_352);
-lean_ctor_set(x_353, 1, x_348);
-x_8 = x_353;
+lean_ctor_set(x_354, 0, x_353);
+lean_ctor_set(x_354, 1, x_349);
+x_8 = x_354;
 goto block_20;
 }
-block_375:
+block_376:
 {
-lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; 
-x_357 = lean_st_ref_get(x_6, x_356);
-x_358 = lean_ctor_get(x_357, 1);
-lean_inc(x_358);
-lean_dec(x_357);
-x_359 = lean_st_ref_take(x_6, x_358);
-x_360 = lean_ctor_get(x_359, 0);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_360, 3);
+lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; 
+x_358 = lean_st_ref_get(x_6, x_357);
+x_359 = lean_ctor_get(x_358, 1);
+lean_inc(x_359);
+lean_dec(x_358);
+x_360 = lean_st_ref_take(x_6, x_359);
+x_361 = lean_ctor_get(x_360, 0);
 lean_inc(x_361);
-x_362 = lean_ctor_get(x_359, 1);
+x_362 = lean_ctor_get(x_361, 3);
 lean_inc(x_362);
-lean_dec(x_359);
-x_363 = lean_ctor_get(x_360, 0);
+x_363 = lean_ctor_get(x_360, 1);
 lean_inc(x_363);
-x_364 = lean_ctor_get(x_360, 1);
+lean_dec(x_360);
+x_364 = lean_ctor_get(x_361, 0);
 lean_inc(x_364);
-x_365 = lean_ctor_get(x_360, 2);
+x_365 = lean_ctor_get(x_361, 1);
 lean_inc(x_365);
-if (lean_is_exclusive(x_360)) {
- lean_ctor_release(x_360, 0);
- lean_ctor_release(x_360, 1);
- lean_ctor_release(x_360, 2);
- lean_ctor_release(x_360, 3);
- x_366 = x_360;
-} else {
- lean_dec_ref(x_360);
- x_366 = lean_box(0);
-}
-x_367 = lean_ctor_get(x_361, 0);
-lean_inc(x_367);
+x_366 = lean_ctor_get(x_361, 2);
+lean_inc(x_366);
 if (lean_is_exclusive(x_361)) {
  lean_ctor_release(x_361, 0);
- x_368 = x_361;
+ lean_ctor_release(x_361, 1);
+ lean_ctor_release(x_361, 2);
+ lean_ctor_release(x_361, 3);
+ x_367 = x_361;
 } else {
  lean_dec_ref(x_361);
- x_368 = lean_box(0);
+ x_367 = lean_box(0);
 }
-if (lean_is_scalar(x_368)) {
- x_369 = lean_alloc_ctor(0, 1, 1);
+x_368 = lean_ctor_get(x_362, 0);
+lean_inc(x_368);
+if (lean_is_exclusive(x_362)) {
+ lean_ctor_release(x_362, 0);
+ x_369 = x_362;
 } else {
- x_369 = x_368;
+ lean_dec_ref(x_362);
+ x_369 = lean_box(0);
 }
-lean_ctor_set(x_369, 0, x_367);
-lean_ctor_set_uint8(x_369, sizeof(void*)*1, x_31);
-if (lean_is_scalar(x_366)) {
- x_370 = lean_alloc_ctor(0, 4, 0);
+if (lean_is_scalar(x_369)) {
+ x_370 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_370 = x_366;
+ x_370 = x_369;
 }
-lean_ctor_set(x_370, 0, x_363);
-lean_ctor_set(x_370, 1, x_364);
-lean_ctor_set(x_370, 2, x_365);
-lean_ctor_set(x_370, 3, x_369);
-x_371 = lean_st_ref_set(x_6, x_370, x_362);
+lean_ctor_set(x_370, 0, x_368);
+lean_ctor_set_uint8(x_370, sizeof(void*)*1, x_31);
+if (lean_is_scalar(x_367)) {
+ x_371 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_371 = x_367;
+}
+lean_ctor_set(x_371, 0, x_364);
+lean_ctor_set(x_371, 1, x_365);
+lean_ctor_set(x_371, 2, x_366);
+lean_ctor_set(x_371, 3, x_370);
+x_372 = lean_st_ref_set(x_6, x_371, x_363);
 lean_dec(x_6);
-x_372 = lean_ctor_get(x_371, 1);
-lean_inc(x_372);
-if (lean_is_exclusive(x_371)) {
- lean_ctor_release(x_371, 0);
- lean_ctor_release(x_371, 1);
- x_373 = x_371;
+x_373 = lean_ctor_get(x_372, 1);
+lean_inc(x_373);
+if (lean_is_exclusive(x_372)) {
+ lean_ctor_release(x_372, 0);
+ lean_ctor_release(x_372, 1);
+ x_374 = x_372;
 } else {
- lean_dec_ref(x_371);
- x_373 = lean_box(0);
+ lean_dec_ref(x_372);
+ x_374 = lean_box(0);
 }
-if (lean_is_scalar(x_373)) {
- x_374 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_374)) {
+ x_375 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_374 = x_373;
- lean_ctor_set_tag(x_374, 1);
+ x_375 = x_374;
+ lean_ctor_set_tag(x_375, 1);
 }
-lean_ctor_set(x_374, 0, x_355);
-lean_ctor_set(x_374, 1, x_372);
-x_8 = x_374;
+lean_ctor_set(x_375, 0, x_356);
+lean_ctor_set(x_375, 1, x_373);
+x_8 = x_375;
 goto block_20;
 }
 }
 }
 else
 {
-lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; lean_object* x_504; uint8_t x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; lean_object* x_509; uint8_t x_510; lean_object* x_511; lean_object* x_537; lean_object* x_538; 
-x_500 = lean_ctor_get(x_33, 0);
-x_501 = lean_ctor_get(x_33, 1);
-x_502 = lean_ctor_get(x_33, 2);
-lean_inc(x_502);
-lean_inc(x_501);
-lean_inc(x_500);
-lean_dec(x_33);
-x_503 = lean_ctor_get(x_34, 0);
+lean_object* x_502; lean_object* x_503; lean_object* x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; uint8_t x_512; lean_object* x_513; lean_object* x_539; lean_object* x_540; 
+x_502 = lean_ctor_get(x_33, 0);
+x_503 = lean_ctor_get(x_33, 1);
+x_504 = lean_ctor_get(x_33, 2);
+lean_inc(x_504);
 lean_inc(x_503);
+lean_inc(x_502);
+lean_dec(x_33);
+x_505 = lean_ctor_get(x_34, 0);
+lean_inc(x_505);
 if (lean_is_exclusive(x_34)) {
  lean_ctor_release(x_34, 0);
- x_504 = x_34;
+ x_506 = x_34;
 } else {
  lean_dec_ref(x_34);
- x_504 = lean_box(0);
+ x_506 = lean_box(0);
 }
-x_505 = 0;
-if (lean_is_scalar(x_504)) {
- x_506 = lean_alloc_ctor(0, 1, 1);
+x_507 = 0;
+if (lean_is_scalar(x_506)) {
+ x_508 = lean_alloc_ctor(0, 1, 1);
 } else {
- x_506 = x_504;
+ x_508 = x_506;
 }
-lean_ctor_set(x_506, 0, x_503);
-lean_ctor_set_uint8(x_506, sizeof(void*)*1, x_505);
-x_507 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_507, 0, x_500);
-lean_ctor_set(x_507, 1, x_501);
-lean_ctor_set(x_507, 2, x_502);
-lean_ctor_set(x_507, 3, x_506);
-x_508 = lean_st_ref_set(x_6, x_507, x_35);
-x_509 = lean_ctor_get(x_508, 1);
-lean_inc(x_509);
-lean_dec(x_508);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set_uint8(x_508, sizeof(void*)*1, x_507);
+x_509 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_509, 0, x_502);
+lean_ctor_set(x_509, 1, x_503);
+lean_ctor_set(x_509, 2, x_504);
+lean_ctor_set(x_509, 3, x_508);
+x_510 = lean_st_ref_set(x_6, x_509, x_35);
+x_511 = lean_ctor_get(x_510, 1);
+lean_inc(x_511);
+lean_dec(x_510);
 if (x_24 == 0)
 {
-lean_object* x_558; 
+lean_object* x_560; 
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_1);
-x_558 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_509);
-if (lean_obj_tag(x_558) == 0)
+x_560 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_511);
+if (lean_obj_tag(x_560) == 0)
 {
-lean_object* x_559; lean_object* x_560; lean_object* x_561; 
-x_559 = lean_ctor_get(x_558, 0);
-lean_inc(x_559);
-x_560 = lean_ctor_get(x_558, 1);
-lean_inc(x_560);
-lean_dec(x_558);
+lean_object* x_561; lean_object* x_562; lean_object* x_563; 
+x_561 = lean_ctor_get(x_560, 0);
+lean_inc(x_561);
+x_562 = lean_ctor_get(x_560, 1);
+lean_inc(x_562);
+lean_dec(x_560);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-x_561 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_560);
-if (lean_obj_tag(x_561) == 0)
+x_563 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_562);
+if (lean_obj_tag(x_563) == 0)
 {
-lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; uint8_t x_568; uint8_t x_569; uint8_t x_570; uint8_t x_571; uint8_t x_572; uint8_t x_573; uint8_t x_574; uint8_t x_575; lean_object* x_576; uint8_t x_577; lean_object* x_578; lean_object* x_579; lean_object* x_580; 
-x_562 = lean_ctor_get(x_3, 0);
-lean_inc(x_562);
-x_563 = lean_ctor_get(x_561, 0);
-lean_inc(x_563);
-x_564 = lean_ctor_get(x_561, 1);
+lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; lean_object* x_568; lean_object* x_569; uint8_t x_570; uint8_t x_571; uint8_t x_572; uint8_t x_573; uint8_t x_574; uint8_t x_575; uint8_t x_576; uint8_t x_577; uint8_t x_578; lean_object* x_579; uint8_t x_580; lean_object* x_581; lean_object* x_582; lean_object* x_583; 
+x_564 = lean_ctor_get(x_3, 0);
 lean_inc(x_564);
-lean_dec(x_561);
-x_565 = lean_ctor_get(x_3, 1);
+x_565 = lean_ctor_get(x_563, 0);
 lean_inc(x_565);
-x_566 = lean_ctor_get(x_3, 2);
+x_566 = lean_ctor_get(x_563, 1);
 lean_inc(x_566);
-x_567 = lean_ctor_get(x_3, 3);
+lean_dec(x_563);
+x_567 = lean_ctor_get(x_3, 1);
 lean_inc(x_567);
-x_568 = lean_ctor_get_uint8(x_562, 0);
-x_569 = lean_ctor_get_uint8(x_562, 1);
-x_570 = lean_ctor_get_uint8(x_562, 2);
-x_571 = lean_ctor_get_uint8(x_562, 3);
-x_572 = lean_ctor_get_uint8(x_562, 4);
-x_573 = lean_ctor_get_uint8(x_562, 6);
-x_574 = lean_ctor_get_uint8(x_562, 7);
-x_575 = lean_ctor_get_uint8(x_562, 8);
-if (lean_is_exclusive(x_562)) {
- x_576 = x_562;
+x_568 = lean_ctor_get(x_3, 2);
+lean_inc(x_568);
+x_569 = lean_ctor_get(x_3, 3);
+lean_inc(x_569);
+x_570 = lean_ctor_get_uint8(x_564, 0);
+x_571 = lean_ctor_get_uint8(x_564, 1);
+x_572 = lean_ctor_get_uint8(x_564, 2);
+x_573 = lean_ctor_get_uint8(x_564, 3);
+x_574 = lean_ctor_get_uint8(x_564, 4);
+x_575 = lean_ctor_get_uint8(x_564, 6);
+x_576 = lean_ctor_get_uint8(x_564, 7);
+x_577 = lean_ctor_get_uint8(x_564, 8);
+x_578 = lean_ctor_get_uint8(x_564, 9);
+if (lean_is_exclusive(x_564)) {
+ x_579 = x_564;
 } else {
- lean_dec_ref(x_562);
- x_576 = lean_box(0);
+ lean_dec_ref(x_564);
+ x_579 = lean_box(0);
 }
-x_577 = 1;
-if (lean_is_scalar(x_576)) {
- x_578 = lean_alloc_ctor(0, 0, 9);
+x_580 = 1;
+if (lean_is_scalar(x_579)) {
+ x_581 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_578 = x_576;
+ x_581 = x_579;
 }
-lean_ctor_set_uint8(x_578, 0, x_568);
-lean_ctor_set_uint8(x_578, 1, x_569);
-lean_ctor_set_uint8(x_578, 2, x_570);
-lean_ctor_set_uint8(x_578, 3, x_571);
-lean_ctor_set_uint8(x_578, 4, x_572);
-lean_ctor_set_uint8(x_578, 5, x_577);
-lean_ctor_set_uint8(x_578, 6, x_573);
-lean_ctor_set_uint8(x_578, 7, x_574);
-lean_ctor_set_uint8(x_578, 8, x_575);
-x_579 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_579, 0, x_578);
-lean_ctor_set(x_579, 1, x_565);
-lean_ctor_set(x_579, 2, x_566);
-lean_ctor_set(x_579, 3, x_567);
+lean_ctor_set_uint8(x_581, 0, x_570);
+lean_ctor_set_uint8(x_581, 1, x_571);
+lean_ctor_set_uint8(x_581, 2, x_572);
+lean_ctor_set_uint8(x_581, 3, x_573);
+lean_ctor_set_uint8(x_581, 4, x_574);
+lean_ctor_set_uint8(x_581, 5, x_580);
+lean_ctor_set_uint8(x_581, 6, x_575);
+lean_ctor_set_uint8(x_581, 7, x_576);
+lean_ctor_set_uint8(x_581, 8, x_577);
+lean_ctor_set_uint8(x_581, 9, x_578);
+x_582 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_582, 0, x_581);
+lean_ctor_set(x_582, 1, x_567);
+lean_ctor_set(x_582, 2, x_568);
+lean_ctor_set(x_582, 3, x_569);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_563);
-lean_inc(x_559);
-x_580 = l_Lean_Meta_isExprDefEqAux(x_559, x_563, x_579, x_4, x_5, x_6, x_564);
-if (lean_obj_tag(x_580) == 0)
+lean_inc(x_565);
+lean_inc(x_561);
+x_583 = l_Lean_Meta_isExprDefEqAux(x_561, x_565, x_582, x_4, x_5, x_6, x_566);
+if (lean_obj_tag(x_583) == 0)
 {
-lean_object* x_581; uint8_t x_582; 
-x_581 = lean_ctor_get(x_580, 0);
-lean_inc(x_581);
-x_582 = lean_unbox(x_581);
-lean_dec(x_581);
-if (x_582 == 0)
+lean_object* x_584; uint8_t x_585; 
+x_584 = lean_ctor_get(x_583, 0);
+lean_inc(x_584);
+x_585 = lean_unbox(x_584);
+lean_dec(x_584);
+if (x_585 == 0)
 {
-lean_object* x_583; uint8_t x_584; lean_object* x_585; lean_object* x_605; lean_object* x_606; lean_object* x_607; uint8_t x_608; 
-x_583 = lean_ctor_get(x_580, 1);
-lean_inc(x_583);
-lean_dec(x_580);
-x_605 = lean_st_ref_get(x_6, x_583);
-x_606 = lean_ctor_get(x_605, 0);
-lean_inc(x_606);
-x_607 = lean_ctor_get(x_606, 3);
-lean_inc(x_607);
-lean_dec(x_606);
-x_608 = lean_ctor_get_uint8(x_607, sizeof(void*)*1);
-lean_dec(x_607);
-if (x_608 == 0)
-{
-lean_object* x_609; 
-x_609 = lean_ctor_get(x_605, 1);
+lean_object* x_586; uint8_t x_587; lean_object* x_588; lean_object* x_608; lean_object* x_609; lean_object* x_610; uint8_t x_611; 
+x_586 = lean_ctor_get(x_583, 1);
+lean_inc(x_586);
+lean_dec(x_583);
+x_608 = lean_st_ref_get(x_6, x_586);
+x_609 = lean_ctor_get(x_608, 0);
 lean_inc(x_609);
-lean_dec(x_605);
-x_584 = x_505;
-x_585 = x_609;
-goto block_604;
+x_610 = lean_ctor_get(x_609, 3);
+lean_inc(x_610);
+lean_dec(x_609);
+x_611 = lean_ctor_get_uint8(x_610, sizeof(void*)*1);
+lean_dec(x_610);
+if (x_611 == 0)
+{
+lean_object* x_612; 
+x_612 = lean_ctor_get(x_608, 1);
+lean_inc(x_612);
+lean_dec(x_608);
+x_587 = x_507;
+x_588 = x_612;
+goto block_607;
 }
 else
 {
-lean_object* x_610; lean_object* x_611; lean_object* x_612; lean_object* x_613; lean_object* x_614; uint8_t x_615; 
-x_610 = lean_ctor_get(x_605, 1);
-lean_inc(x_610);
-lean_dec(x_605);
-x_611 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_612 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_611, x_3, x_4, x_5, x_6, x_610);
-x_613 = lean_ctor_get(x_612, 0);
+lean_object* x_613; lean_object* x_614; lean_object* x_615; lean_object* x_616; lean_object* x_617; uint8_t x_618; 
+x_613 = lean_ctor_get(x_608, 1);
 lean_inc(x_613);
-x_614 = lean_ctor_get(x_612, 1);
-lean_inc(x_614);
-lean_dec(x_612);
-x_615 = lean_unbox(x_613);
-lean_dec(x_613);
-x_584 = x_615;
-x_585 = x_614;
-goto block_604;
+lean_dec(x_608);
+x_614 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_615 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_614, x_3, x_4, x_5, x_6, x_613);
+x_616 = lean_ctor_get(x_615, 0);
+lean_inc(x_616);
+x_617 = lean_ctor_get(x_615, 1);
+lean_inc(x_617);
+lean_dec(x_615);
+x_618 = lean_unbox(x_616);
+lean_dec(x_616);
+x_587 = x_618;
+x_588 = x_617;
+goto block_607;
 }
-block_604:
+block_607:
 {
-if (x_584 == 0)
+if (x_587 == 0)
 {
-lean_dec(x_563);
-lean_dec(x_559);
+lean_dec(x_565);
+lean_dec(x_561);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_510 = x_505;
-x_511 = x_585;
-goto block_536;
+x_512 = x_507;
+x_513 = x_588;
+goto block_538;
 }
 else
 {
-lean_object* x_586; lean_object* x_587; lean_object* x_588; lean_object* x_589; lean_object* x_590; lean_object* x_591; lean_object* x_592; lean_object* x_593; lean_object* x_594; lean_object* x_595; lean_object* x_596; lean_object* x_597; lean_object* x_598; lean_object* x_599; lean_object* x_600; lean_object* x_601; lean_object* x_602; lean_object* x_603; 
-x_586 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_586, 0, x_1);
-x_587 = l_Lean_KernelException_toMessageData___closed__15;
-x_588 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_588, 0, x_587);
-lean_ctor_set(x_588, 1, x_586);
-x_589 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
-x_590 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_590, 0, x_588);
-lean_ctor_set(x_590, 1, x_589);
-x_591 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_591, 0, x_559);
-x_592 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_592, 0, x_590);
-lean_ctor_set(x_592, 1, x_591);
-x_593 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_594 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_594, 0, x_592);
-lean_ctor_set(x_594, 1, x_593);
-x_595 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_595, 0, x_2);
-x_596 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_596, 0, x_594);
-lean_ctor_set(x_596, 1, x_595);
+lean_object* x_589; lean_object* x_590; lean_object* x_591; lean_object* x_592; lean_object* x_593; lean_object* x_594; lean_object* x_595; lean_object* x_596; lean_object* x_597; lean_object* x_598; lean_object* x_599; lean_object* x_600; lean_object* x_601; lean_object* x_602; lean_object* x_603; lean_object* x_604; lean_object* x_605; lean_object* x_606; 
+x_589 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_589, 0, x_1);
+x_590 = l_Lean_KernelException_toMessageData___closed__15;
+x_591 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_591, 0, x_590);
+lean_ctor_set(x_591, 1, x_589);
+x_592 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
+x_593 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_593, 0, x_591);
+lean_ctor_set(x_593, 1, x_592);
+x_594 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_594, 0, x_561);
+x_595 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_595, 0, x_593);
+lean_ctor_set(x_595, 1, x_594);
+x_596 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
 x_597 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_597, 0, x_596);
-lean_ctor_set(x_597, 1, x_589);
+lean_ctor_set(x_597, 0, x_595);
+lean_ctor_set(x_597, 1, x_596);
 x_598 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_598, 0, x_563);
+lean_ctor_set(x_598, 0, x_2);
 x_599 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_599, 0, x_597);
 lean_ctor_set(x_599, 1, x_598);
 x_600 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_600, 0, x_599);
-lean_ctor_set(x_600, 1, x_587);
-x_601 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_602 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_601, x_600, x_3, x_4, x_5, x_6, x_585);
+lean_ctor_set(x_600, 1, x_592);
+x_601 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_601, 0, x_565);
+x_602 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_602, 0, x_600);
+lean_ctor_set(x_602, 1, x_601);
+x_603 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_603, 0, x_602);
+lean_ctor_set(x_603, 1, x_590);
+x_604 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_605 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_604, x_603, x_3, x_4, x_5, x_6, x_588);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_603 = lean_ctor_get(x_602, 1);
-lean_inc(x_603);
-lean_dec(x_602);
-x_510 = x_505;
-x_511 = x_603;
-goto block_536;
+x_606 = lean_ctor_get(x_605, 1);
+lean_inc(x_606);
+lean_dec(x_605);
+x_512 = x_507;
+x_513 = x_606;
+goto block_538;
 }
 }
 }
 else
 {
-lean_object* x_616; uint8_t x_617; lean_object* x_618; lean_object* x_639; lean_object* x_640; lean_object* x_641; uint8_t x_642; 
-lean_dec(x_563);
-lean_dec(x_559);
-x_616 = lean_ctor_get(x_580, 1);
-lean_inc(x_616);
-lean_dec(x_580);
-x_639 = lean_st_ref_get(x_6, x_616);
-x_640 = lean_ctor_get(x_639, 0);
-lean_inc(x_640);
-x_641 = lean_ctor_get(x_640, 3);
-lean_inc(x_641);
-lean_dec(x_640);
-x_642 = lean_ctor_get_uint8(x_641, sizeof(void*)*1);
-lean_dec(x_641);
-if (x_642 == 0)
-{
-lean_object* x_643; 
-x_643 = lean_ctor_get(x_639, 1);
+lean_object* x_619; uint8_t x_620; lean_object* x_621; lean_object* x_642; lean_object* x_643; lean_object* x_644; uint8_t x_645; 
+lean_dec(x_565);
+lean_dec(x_561);
+x_619 = lean_ctor_get(x_583, 1);
+lean_inc(x_619);
+lean_dec(x_583);
+x_642 = lean_st_ref_get(x_6, x_619);
+x_643 = lean_ctor_get(x_642, 0);
 lean_inc(x_643);
-lean_dec(x_639);
-x_617 = x_505;
-x_618 = x_643;
-goto block_638;
-}
-else
-{
-lean_object* x_644; lean_object* x_645; lean_object* x_646; lean_object* x_647; lean_object* x_648; uint8_t x_649; 
-x_644 = lean_ctor_get(x_639, 1);
+x_644 = lean_ctor_get(x_643, 3);
 lean_inc(x_644);
-lean_dec(x_639);
-x_645 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_646 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_645, x_3, x_4, x_5, x_6, x_644);
-x_647 = lean_ctor_get(x_646, 0);
-lean_inc(x_647);
-x_648 = lean_ctor_get(x_646, 1);
-lean_inc(x_648);
-lean_dec(x_646);
-x_649 = lean_unbox(x_647);
-lean_dec(x_647);
-x_617 = x_649;
-x_618 = x_648;
-goto block_638;
-}
-block_638:
+lean_dec(x_643);
+x_645 = lean_ctor_get_uint8(x_644, sizeof(void*)*1);
+lean_dec(x_644);
+if (x_645 == 0)
 {
-if (x_617 == 0)
-{
-lean_object* x_619; lean_object* x_620; lean_object* x_621; uint8_t x_622; 
-x_619 = l_Lean_Expr_mvarId_x21(x_1);
-lean_dec(x_1);
-x_620 = l_Lean_Meta_assignExprMVar(x_619, x_2, x_3, x_4, x_5, x_6, x_618);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_621 = lean_ctor_get(x_620, 1);
-lean_inc(x_621);
-lean_dec(x_620);
-x_622 = 1;
-x_510 = x_622;
-x_511 = x_621;
-goto block_536;
+lean_object* x_646; 
+x_646 = lean_ctor_get(x_642, 1);
+lean_inc(x_646);
+lean_dec(x_642);
+x_620 = x_507;
+x_621 = x_646;
+goto block_641;
 }
 else
 {
-lean_object* x_623; lean_object* x_624; lean_object* x_625; lean_object* x_626; lean_object* x_627; lean_object* x_628; lean_object* x_629; lean_object* x_630; lean_object* x_631; lean_object* x_632; lean_object* x_633; lean_object* x_634; lean_object* x_635; lean_object* x_636; uint8_t x_637; 
-lean_inc(x_1);
-x_623 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_623, 0, x_1);
-x_624 = l_Lean_KernelException_toMessageData___closed__15;
-x_625 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_625, 0, x_624);
-lean_ctor_set(x_625, 1, x_623);
-x_626 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_627 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_627, 0, x_625);
-lean_ctor_set(x_627, 1, x_626);
-lean_inc(x_2);
-x_628 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_628, 0, x_2);
-x_629 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_629, 0, x_627);
-lean_ctor_set(x_629, 1, x_628);
-x_630 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_630, 0, x_629);
-lean_ctor_set(x_630, 1, x_624);
-x_631 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_632 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_631, x_630, x_3, x_4, x_5, x_6, x_618);
-x_633 = lean_ctor_get(x_632, 1);
-lean_inc(x_633);
-lean_dec(x_632);
-x_634 = l_Lean_Expr_mvarId_x21(x_1);
+lean_object* x_647; lean_object* x_648; lean_object* x_649; lean_object* x_650; lean_object* x_651; uint8_t x_652; 
+x_647 = lean_ctor_get(x_642, 1);
+lean_inc(x_647);
+lean_dec(x_642);
+x_648 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_649 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_648, x_3, x_4, x_5, x_6, x_647);
+x_650 = lean_ctor_get(x_649, 0);
+lean_inc(x_650);
+x_651 = lean_ctor_get(x_649, 1);
+lean_inc(x_651);
+lean_dec(x_649);
+x_652 = lean_unbox(x_650);
+lean_dec(x_650);
+x_620 = x_652;
+x_621 = x_651;
+goto block_641;
+}
+block_641:
+{
+if (x_620 == 0)
+{
+lean_object* x_622; lean_object* x_623; lean_object* x_624; uint8_t x_625; 
+x_622 = l_Lean_Expr_mvarId_x21(x_1);
 lean_dec(x_1);
-x_635 = l_Lean_Meta_assignExprMVar(x_634, x_2, x_3, x_4, x_5, x_6, x_633);
+x_623 = l_Lean_Meta_assignExprMVar(x_622, x_2, x_3, x_4, x_5, x_6, x_621);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
+x_624 = lean_ctor_get(x_623, 1);
+lean_inc(x_624);
+lean_dec(x_623);
+x_625 = 1;
+x_512 = x_625;
+x_513 = x_624;
+goto block_538;
+}
+else
+{
+lean_object* x_626; lean_object* x_627; lean_object* x_628; lean_object* x_629; lean_object* x_630; lean_object* x_631; lean_object* x_632; lean_object* x_633; lean_object* x_634; lean_object* x_635; lean_object* x_636; lean_object* x_637; lean_object* x_638; lean_object* x_639; uint8_t x_640; 
+lean_inc(x_1);
+x_626 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_626, 0, x_1);
+x_627 = l_Lean_KernelException_toMessageData___closed__15;
+x_628 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_628, 0, x_627);
+lean_ctor_set(x_628, 1, x_626);
+x_629 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_630 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_630, 0, x_628);
+lean_ctor_set(x_630, 1, x_629);
+lean_inc(x_2);
+x_631 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_631, 0, x_2);
+x_632 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_632, 0, x_630);
+lean_ctor_set(x_632, 1, x_631);
+x_633 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_633, 0, x_632);
+lean_ctor_set(x_633, 1, x_627);
+x_634 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_635 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_634, x_633, x_3, x_4, x_5, x_6, x_621);
 x_636 = lean_ctor_get(x_635, 1);
 lean_inc(x_636);
 lean_dec(x_635);
-x_637 = 1;
-x_510 = x_637;
-x_511 = x_636;
-goto block_536;
+x_637 = l_Lean_Expr_mvarId_x21(x_1);
+lean_dec(x_1);
+x_638 = l_Lean_Meta_assignExprMVar(x_637, x_2, x_3, x_4, x_5, x_6, x_636);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_639 = lean_ctor_get(x_638, 1);
+lean_inc(x_639);
+lean_dec(x_638);
+x_640 = 1;
+x_512 = x_640;
+x_513 = x_639;
+goto block_538;
 }
 }
 }
 }
 else
 {
-lean_object* x_650; lean_object* x_651; 
-lean_dec(x_563);
-lean_dec(x_559);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-x_650 = lean_ctor_get(x_580, 0);
-lean_inc(x_650);
-x_651 = lean_ctor_get(x_580, 1);
-lean_inc(x_651);
-lean_dec(x_580);
-x_537 = x_650;
-x_538 = x_651;
-goto block_557;
-}
-}
-else
-{
-lean_object* x_652; lean_object* x_653; 
-lean_dec(x_559);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-x_652 = lean_ctor_get(x_561, 0);
-lean_inc(x_652);
-x_653 = lean_ctor_get(x_561, 1);
-lean_inc(x_653);
+lean_object* x_653; lean_object* x_654; 
+lean_dec(x_565);
 lean_dec(x_561);
-x_537 = x_652;
-x_538 = x_653;
-goto block_557;
-}
-}
-else
-{
-lean_object* x_654; lean_object* x_655; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_654 = lean_ctor_get(x_558, 0);
+x_653 = lean_ctor_get(x_583, 0);
+lean_inc(x_653);
+x_654 = lean_ctor_get(x_583, 1);
 lean_inc(x_654);
-x_655 = lean_ctor_get(x_558, 1);
+lean_dec(x_583);
+x_539 = x_653;
+x_540 = x_654;
+goto block_559;
+}
+}
+else
+{
+lean_object* x_655; lean_object* x_656; 
+lean_dec(x_561);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_655 = lean_ctor_get(x_563, 0);
 lean_inc(x_655);
-lean_dec(x_558);
-x_537 = x_654;
-x_538 = x_655;
-goto block_557;
+x_656 = lean_ctor_get(x_563, 1);
+lean_inc(x_656);
+lean_dec(x_563);
+x_539 = x_655;
+x_540 = x_656;
+goto block_559;
 }
 }
 else
 {
-uint8_t x_656; lean_object* x_657; lean_object* x_671; lean_object* x_672; lean_object* x_673; uint8_t x_674; 
-x_671 = lean_st_ref_get(x_6, x_509);
-x_672 = lean_ctor_get(x_671, 0);
-lean_inc(x_672);
-x_673 = lean_ctor_get(x_672, 3);
-lean_inc(x_673);
-lean_dec(x_672);
-x_674 = lean_ctor_get_uint8(x_673, sizeof(void*)*1);
-lean_dec(x_673);
-if (x_674 == 0)
+lean_object* x_657; lean_object* x_658; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_657 = lean_ctor_get(x_560, 0);
+lean_inc(x_657);
+x_658 = lean_ctor_get(x_560, 1);
+lean_inc(x_658);
+lean_dec(x_560);
+x_539 = x_657;
+x_540 = x_658;
+goto block_559;
+}
+}
+else
 {
-lean_object* x_675; 
-x_675 = lean_ctor_get(x_671, 1);
+uint8_t x_659; lean_object* x_660; lean_object* x_674; lean_object* x_675; lean_object* x_676; uint8_t x_677; 
+x_674 = lean_st_ref_get(x_6, x_511);
+x_675 = lean_ctor_get(x_674, 0);
 lean_inc(x_675);
-lean_dec(x_671);
-x_656 = x_505;
-x_657 = x_675;
-goto block_670;
+x_676 = lean_ctor_get(x_675, 3);
+lean_inc(x_676);
+lean_dec(x_675);
+x_677 = lean_ctor_get_uint8(x_676, sizeof(void*)*1);
+lean_dec(x_676);
+if (x_677 == 0)
+{
+lean_object* x_678; 
+x_678 = lean_ctor_get(x_674, 1);
+lean_inc(x_678);
+lean_dec(x_674);
+x_659 = x_507;
+x_660 = x_678;
+goto block_673;
 }
 else
 {
-lean_object* x_676; lean_object* x_677; lean_object* x_678; lean_object* x_679; lean_object* x_680; uint8_t x_681; 
-x_676 = lean_ctor_get(x_671, 1);
-lean_inc(x_676);
-lean_dec(x_671);
-x_677 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_678 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_677, x_3, x_4, x_5, x_6, x_676);
-x_679 = lean_ctor_get(x_678, 0);
+lean_object* x_679; lean_object* x_680; lean_object* x_681; lean_object* x_682; lean_object* x_683; uint8_t x_684; 
+x_679 = lean_ctor_get(x_674, 1);
 lean_inc(x_679);
-x_680 = lean_ctor_get(x_678, 1);
-lean_inc(x_680);
-lean_dec(x_678);
-x_681 = lean_unbox(x_679);
-lean_dec(x_679);
-x_656 = x_681;
-x_657 = x_680;
-goto block_670;
+lean_dec(x_674);
+x_680 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_681 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_680, x_3, x_4, x_5, x_6, x_679);
+x_682 = lean_ctor_get(x_681, 0);
+lean_inc(x_682);
+x_683 = lean_ctor_get(x_681, 1);
+lean_inc(x_683);
+lean_dec(x_681);
+x_684 = lean_unbox(x_682);
+lean_dec(x_682);
+x_659 = x_684;
+x_660 = x_683;
+goto block_673;
 }
-block_670:
+block_673:
 {
-if (x_656 == 0)
+if (x_659 == 0)
 {
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_510 = x_505;
-x_511 = x_657;
-goto block_536;
+x_512 = x_507;
+x_513 = x_660;
+goto block_538;
 }
 else
 {
-lean_object* x_658; lean_object* x_659; lean_object* x_660; lean_object* x_661; lean_object* x_662; lean_object* x_663; lean_object* x_664; lean_object* x_665; lean_object* x_666; lean_object* x_667; lean_object* x_668; lean_object* x_669; 
-x_658 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_658, 0, x_1);
-x_659 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
-x_660 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_660, 0, x_659);
-lean_ctor_set(x_660, 1, x_658);
-x_661 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_662 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_662, 0, x_660);
-lean_ctor_set(x_662, 1, x_661);
-x_663 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_663, 0, x_2);
-x_664 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_664, 0, x_662);
-lean_ctor_set(x_664, 1, x_663);
-x_665 = l_Lean_KernelException_toMessageData___closed__15;
-x_666 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_666, 0, x_664);
-lean_ctor_set(x_666, 1, x_665);
-x_667 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_668 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_667, x_666, x_3, x_4, x_5, x_6, x_657);
+lean_object* x_661; lean_object* x_662; lean_object* x_663; lean_object* x_664; lean_object* x_665; lean_object* x_666; lean_object* x_667; lean_object* x_668; lean_object* x_669; lean_object* x_670; lean_object* x_671; lean_object* x_672; 
+x_661 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_661, 0, x_1);
+x_662 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
+x_663 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_663, 0, x_662);
+lean_ctor_set(x_663, 1, x_661);
+x_664 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_665 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_665, 0, x_663);
+lean_ctor_set(x_665, 1, x_664);
+x_666 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_666, 0, x_2);
+x_667 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_667, 0, x_665);
+lean_ctor_set(x_667, 1, x_666);
+x_668 = l_Lean_KernelException_toMessageData___closed__15;
+x_669 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_669, 0, x_667);
+lean_ctor_set(x_669, 1, x_668);
+x_670 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_671 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_670, x_669, x_3, x_4, x_5, x_6, x_660);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_669 = lean_ctor_get(x_668, 1);
-lean_inc(x_669);
-lean_dec(x_668);
-x_510 = x_505;
-x_511 = x_669;
-goto block_536;
+x_672 = lean_ctor_get(x_671, 1);
+lean_inc(x_672);
+lean_dec(x_671);
+x_512 = x_507;
+x_513 = x_672;
+goto block_538;
 }
 }
 }
-block_536:
+block_538:
 {
-lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; uint8_t x_516; lean_object* x_517; lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; 
-x_512 = lean_st_ref_get(x_6, x_511);
-x_513 = lean_ctor_get(x_512, 0);
-lean_inc(x_513);
-x_514 = lean_ctor_get(x_512, 1);
-lean_inc(x_514);
-lean_dec(x_512);
-x_515 = lean_ctor_get(x_513, 3);
+lean_object* x_514; lean_object* x_515; lean_object* x_516; lean_object* x_517; uint8_t x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; 
+x_514 = lean_st_ref_get(x_6, x_513);
+x_515 = lean_ctor_get(x_514, 0);
 lean_inc(x_515);
-lean_dec(x_513);
-x_516 = lean_ctor_get_uint8(x_515, sizeof(void*)*1);
+x_516 = lean_ctor_get(x_514, 1);
+lean_inc(x_516);
+lean_dec(x_514);
+x_517 = lean_ctor_get(x_515, 3);
+lean_inc(x_517);
 lean_dec(x_515);
-x_517 = lean_st_ref_take(x_6, x_514);
-x_518 = lean_ctor_get(x_517, 0);
-lean_inc(x_518);
-x_519 = lean_ctor_get(x_518, 3);
-lean_inc(x_519);
-x_520 = lean_ctor_get(x_517, 1);
-lean_inc(x_520);
+x_518 = lean_ctor_get_uint8(x_517, sizeof(void*)*1);
 lean_dec(x_517);
-x_521 = lean_ctor_get(x_518, 0);
+x_519 = lean_st_ref_take(x_6, x_516);
+x_520 = lean_ctor_get(x_519, 0);
+lean_inc(x_520);
+x_521 = lean_ctor_get(x_520, 3);
 lean_inc(x_521);
-x_522 = lean_ctor_get(x_518, 1);
+x_522 = lean_ctor_get(x_519, 1);
 lean_inc(x_522);
-x_523 = lean_ctor_get(x_518, 2);
+lean_dec(x_519);
+x_523 = lean_ctor_get(x_520, 0);
 lean_inc(x_523);
-if (lean_is_exclusive(x_518)) {
- lean_ctor_release(x_518, 0);
- lean_ctor_release(x_518, 1);
- lean_ctor_release(x_518, 2);
- lean_ctor_release(x_518, 3);
- x_524 = x_518;
-} else {
- lean_dec_ref(x_518);
- x_524 = lean_box(0);
-}
-x_525 = lean_ctor_get(x_519, 0);
+x_524 = lean_ctor_get(x_520, 1);
+lean_inc(x_524);
+x_525 = lean_ctor_get(x_520, 2);
 lean_inc(x_525);
-if (lean_is_exclusive(x_519)) {
- lean_ctor_release(x_519, 0);
- x_526 = x_519;
+if (lean_is_exclusive(x_520)) {
+ lean_ctor_release(x_520, 0);
+ lean_ctor_release(x_520, 1);
+ lean_ctor_release(x_520, 2);
+ lean_ctor_release(x_520, 3);
+ x_526 = x_520;
 } else {
- lean_dec_ref(x_519);
+ lean_dec_ref(x_520);
  x_526 = lean_box(0);
 }
+x_527 = lean_ctor_get(x_521, 0);
+lean_inc(x_527);
+if (lean_is_exclusive(x_521)) {
+ lean_ctor_release(x_521, 0);
+ x_528 = x_521;
+} else {
+ lean_dec_ref(x_521);
+ x_528 = lean_box(0);
+}
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(0, 1, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_527);
+lean_ctor_set_uint8(x_529, sizeof(void*)*1, x_31);
 if (lean_is_scalar(x_526)) {
- x_527 = lean_alloc_ctor(0, 1, 1);
+ x_530 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_527 = x_526;
+ x_530 = x_526;
 }
-lean_ctor_set(x_527, 0, x_525);
-lean_ctor_set_uint8(x_527, sizeof(void*)*1, x_31);
-if (lean_is_scalar(x_524)) {
- x_528 = lean_alloc_ctor(0, 4, 0);
-} else {
- x_528 = x_524;
-}
-lean_ctor_set(x_528, 0, x_521);
-lean_ctor_set(x_528, 1, x_522);
-lean_ctor_set(x_528, 2, x_523);
-lean_ctor_set(x_528, 3, x_527);
-x_529 = lean_st_ref_set(x_6, x_528, x_520);
+lean_ctor_set(x_530, 0, x_523);
+lean_ctor_set(x_530, 1, x_524);
+lean_ctor_set(x_530, 2, x_525);
+lean_ctor_set(x_530, 3, x_529);
+x_531 = lean_st_ref_set(x_6, x_530, x_522);
 lean_dec(x_6);
-x_530 = lean_ctor_get(x_529, 1);
-lean_inc(x_530);
-if (lean_is_exclusive(x_529)) {
- lean_ctor_release(x_529, 0);
- lean_ctor_release(x_529, 1);
- x_531 = x_529;
+x_532 = lean_ctor_get(x_531, 1);
+lean_inc(x_532);
+if (lean_is_exclusive(x_531)) {
+ lean_ctor_release(x_531, 0);
+ lean_ctor_release(x_531, 1);
+ x_533 = x_531;
 } else {
- lean_dec_ref(x_529);
- x_531 = lean_box(0);
+ lean_dec_ref(x_531);
+ x_533 = lean_box(0);
 }
-x_532 = lean_box(x_510);
-x_533 = lean_box(x_516);
-x_534 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_534, 0, x_532);
-lean_ctor_set(x_534, 1, x_533);
-if (lean_is_scalar(x_531)) {
- x_535 = lean_alloc_ctor(0, 2, 0);
+x_534 = lean_box(x_512);
+x_535 = lean_box(x_518);
+x_536 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_536, 0, x_534);
+lean_ctor_set(x_536, 1, x_535);
+if (lean_is_scalar(x_533)) {
+ x_537 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_535 = x_531;
+ x_537 = x_533;
 }
-lean_ctor_set(x_535, 0, x_534);
-lean_ctor_set(x_535, 1, x_530);
-x_8 = x_535;
+lean_ctor_set(x_537, 0, x_536);
+lean_ctor_set(x_537, 1, x_532);
+x_8 = x_537;
 goto block_20;
 }
-block_557:
+block_559:
 {
-lean_object* x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; lean_object* x_554; lean_object* x_555; lean_object* x_556; 
-x_539 = lean_st_ref_get(x_6, x_538);
-x_540 = lean_ctor_get(x_539, 1);
-lean_inc(x_540);
-lean_dec(x_539);
-x_541 = lean_st_ref_take(x_6, x_540);
-x_542 = lean_ctor_get(x_541, 0);
+lean_object* x_541; lean_object* x_542; lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; lean_object* x_554; lean_object* x_555; lean_object* x_556; lean_object* x_557; lean_object* x_558; 
+x_541 = lean_st_ref_get(x_6, x_540);
+x_542 = lean_ctor_get(x_541, 1);
 lean_inc(x_542);
-x_543 = lean_ctor_get(x_542, 3);
-lean_inc(x_543);
-x_544 = lean_ctor_get(x_541, 1);
-lean_inc(x_544);
 lean_dec(x_541);
-x_545 = lean_ctor_get(x_542, 0);
+x_543 = lean_st_ref_take(x_6, x_542);
+x_544 = lean_ctor_get(x_543, 0);
+lean_inc(x_544);
+x_545 = lean_ctor_get(x_544, 3);
 lean_inc(x_545);
-x_546 = lean_ctor_get(x_542, 1);
+x_546 = lean_ctor_get(x_543, 1);
 lean_inc(x_546);
-x_547 = lean_ctor_get(x_542, 2);
+lean_dec(x_543);
+x_547 = lean_ctor_get(x_544, 0);
 lean_inc(x_547);
-if (lean_is_exclusive(x_542)) {
- lean_ctor_release(x_542, 0);
- lean_ctor_release(x_542, 1);
- lean_ctor_release(x_542, 2);
- lean_ctor_release(x_542, 3);
- x_548 = x_542;
-} else {
- lean_dec_ref(x_542);
- x_548 = lean_box(0);
-}
-x_549 = lean_ctor_get(x_543, 0);
+x_548 = lean_ctor_get(x_544, 1);
+lean_inc(x_548);
+x_549 = lean_ctor_get(x_544, 2);
 lean_inc(x_549);
-if (lean_is_exclusive(x_543)) {
- lean_ctor_release(x_543, 0);
- x_550 = x_543;
+if (lean_is_exclusive(x_544)) {
+ lean_ctor_release(x_544, 0);
+ lean_ctor_release(x_544, 1);
+ lean_ctor_release(x_544, 2);
+ lean_ctor_release(x_544, 3);
+ x_550 = x_544;
 } else {
- lean_dec_ref(x_543);
+ lean_dec_ref(x_544);
  x_550 = lean_box(0);
 }
+x_551 = lean_ctor_get(x_545, 0);
+lean_inc(x_551);
+if (lean_is_exclusive(x_545)) {
+ lean_ctor_release(x_545, 0);
+ x_552 = x_545;
+} else {
+ lean_dec_ref(x_545);
+ x_552 = lean_box(0);
+}
+if (lean_is_scalar(x_552)) {
+ x_553 = lean_alloc_ctor(0, 1, 1);
+} else {
+ x_553 = x_552;
+}
+lean_ctor_set(x_553, 0, x_551);
+lean_ctor_set_uint8(x_553, sizeof(void*)*1, x_31);
 if (lean_is_scalar(x_550)) {
- x_551 = lean_alloc_ctor(0, 1, 1);
+ x_554 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_551 = x_550;
+ x_554 = x_550;
 }
-lean_ctor_set(x_551, 0, x_549);
-lean_ctor_set_uint8(x_551, sizeof(void*)*1, x_31);
-if (lean_is_scalar(x_548)) {
- x_552 = lean_alloc_ctor(0, 4, 0);
-} else {
- x_552 = x_548;
-}
-lean_ctor_set(x_552, 0, x_545);
-lean_ctor_set(x_552, 1, x_546);
-lean_ctor_set(x_552, 2, x_547);
-lean_ctor_set(x_552, 3, x_551);
-x_553 = lean_st_ref_set(x_6, x_552, x_544);
+lean_ctor_set(x_554, 0, x_547);
+lean_ctor_set(x_554, 1, x_548);
+lean_ctor_set(x_554, 2, x_549);
+lean_ctor_set(x_554, 3, x_553);
+x_555 = lean_st_ref_set(x_6, x_554, x_546);
 lean_dec(x_6);
-x_554 = lean_ctor_get(x_553, 1);
-lean_inc(x_554);
-if (lean_is_exclusive(x_553)) {
- lean_ctor_release(x_553, 0);
- lean_ctor_release(x_553, 1);
- x_555 = x_553;
+x_556 = lean_ctor_get(x_555, 1);
+lean_inc(x_556);
+if (lean_is_exclusive(x_555)) {
+ lean_ctor_release(x_555, 0);
+ lean_ctor_release(x_555, 1);
+ x_557 = x_555;
 } else {
- lean_dec_ref(x_553);
- x_555 = lean_box(0);
+ lean_dec_ref(x_555);
+ x_557 = lean_box(0);
 }
-if (lean_is_scalar(x_555)) {
- x_556 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_557)) {
+ x_558 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_556 = x_555;
- lean_ctor_set_tag(x_556, 1);
+ x_558 = x_557;
+ lean_ctor_set_tag(x_558, 1);
 }
-lean_ctor_set(x_556, 0, x_537);
-lean_ctor_set(x_556, 1, x_554);
-x_8 = x_556;
+lean_ctor_set(x_558, 0, x_539);
+lean_ctor_set(x_558, 1, x_556);
+x_8 = x_558;
 goto block_20;
 }
 }
 }
 else
 {
-lean_object* x_682; lean_object* x_683; lean_object* x_684; lean_object* x_685; uint8_t x_686; lean_object* x_687; lean_object* x_697; lean_object* x_698; 
-x_682 = lean_ctor_get(x_5, 3);
-lean_inc(x_682);
-x_683 = l___private_Lean_Util_Trace_0__Lean_getResetTraces___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__6___rarg(x_6, x_26);
-x_684 = lean_ctor_get(x_683, 0);
-lean_inc(x_684);
-x_685 = lean_ctor_get(x_683, 1);
+lean_object* x_685; lean_object* x_686; lean_object* x_687; lean_object* x_688; uint8_t x_689; lean_object* x_690; lean_object* x_700; lean_object* x_701; 
+x_685 = lean_ctor_get(x_5, 3);
 lean_inc(x_685);
-lean_dec(x_683);
+x_686 = l___private_Lean_Util_Trace_0__Lean_getResetTraces___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__6___rarg(x_6, x_26);
+x_687 = lean_ctor_get(x_686, 0);
+lean_inc(x_687);
+x_688 = lean_ctor_get(x_686, 1);
+lean_inc(x_688);
+lean_dec(x_686);
 if (x_24 == 0)
 {
-lean_object* x_706; 
+lean_object* x_709; 
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_1);
-x_706 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_685);
-if (lean_obj_tag(x_706) == 0)
+x_709 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_688);
+if (lean_obj_tag(x_709) == 0)
 {
-lean_object* x_707; lean_object* x_708; lean_object* x_709; 
-x_707 = lean_ctor_get(x_706, 0);
-lean_inc(x_707);
-x_708 = lean_ctor_get(x_706, 1);
-lean_inc(x_708);
-lean_dec(x_706);
+lean_object* x_710; lean_object* x_711; lean_object* x_712; 
+x_710 = lean_ctor_get(x_709, 0);
+lean_inc(x_710);
+x_711 = lean_ctor_get(x_709, 1);
+lean_inc(x_711);
+lean_dec(x_709);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-x_709 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_708);
-if (lean_obj_tag(x_709) == 0)
+x_712 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_711);
+if (lean_obj_tag(x_712) == 0)
 {
-lean_object* x_710; lean_object* x_711; lean_object* x_712; lean_object* x_713; lean_object* x_714; lean_object* x_715; uint8_t x_716; 
-x_710 = lean_ctor_get(x_3, 0);
-lean_inc(x_710);
-x_711 = lean_ctor_get(x_709, 0);
-lean_inc(x_711);
-x_712 = lean_ctor_get(x_709, 1);
-lean_inc(x_712);
-lean_dec(x_709);
-x_713 = lean_ctor_get(x_3, 1);
+lean_object* x_713; lean_object* x_714; lean_object* x_715; lean_object* x_716; lean_object* x_717; lean_object* x_718; uint8_t x_719; 
+x_713 = lean_ctor_get(x_3, 0);
 lean_inc(x_713);
-x_714 = lean_ctor_get(x_3, 2);
+x_714 = lean_ctor_get(x_712, 0);
 lean_inc(x_714);
-x_715 = lean_ctor_get(x_3, 3);
+x_715 = lean_ctor_get(x_712, 1);
 lean_inc(x_715);
-x_716 = !lean_is_exclusive(x_710);
-if (x_716 == 0)
+lean_dec(x_712);
+x_716 = lean_ctor_get(x_3, 1);
+lean_inc(x_716);
+x_717 = lean_ctor_get(x_3, 2);
+lean_inc(x_717);
+x_718 = lean_ctor_get(x_3, 3);
+lean_inc(x_718);
+x_719 = !lean_is_exclusive(x_713);
+if (x_719 == 0)
 {
-uint8_t x_717; lean_object* x_718; lean_object* x_719; 
-x_717 = 1;
-lean_ctor_set_uint8(x_710, 5, x_717);
-x_718 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_718, 0, x_710);
-lean_ctor_set(x_718, 1, x_713);
-lean_ctor_set(x_718, 2, x_714);
-lean_ctor_set(x_718, 3, x_715);
+uint8_t x_720; lean_object* x_721; lean_object* x_722; 
+x_720 = 1;
+lean_ctor_set_uint8(x_713, 5, x_720);
+x_721 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_721, 0, x_713);
+lean_ctor_set(x_721, 1, x_716);
+lean_ctor_set(x_721, 2, x_717);
+lean_ctor_set(x_721, 3, x_718);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_711);
-lean_inc(x_707);
-x_719 = l_Lean_Meta_isExprDefEqAux(x_707, x_711, x_718, x_4, x_5, x_6, x_712);
-if (lean_obj_tag(x_719) == 0)
+lean_inc(x_714);
+lean_inc(x_710);
+x_722 = l_Lean_Meta_isExprDefEqAux(x_710, x_714, x_721, x_4, x_5, x_6, x_715);
+if (lean_obj_tag(x_722) == 0)
 {
-lean_object* x_720; uint8_t x_721; 
-x_720 = lean_ctor_get(x_719, 0);
-lean_inc(x_720);
-x_721 = lean_unbox(x_720);
-lean_dec(x_720);
-if (x_721 == 0)
+lean_object* x_723; uint8_t x_724; 
+x_723 = lean_ctor_get(x_722, 0);
+lean_inc(x_723);
+x_724 = lean_unbox(x_723);
+lean_dec(x_723);
+if (x_724 == 0)
 {
-lean_object* x_722; uint8_t x_723; lean_object* x_724; lean_object* x_746; lean_object* x_747; lean_object* x_748; uint8_t x_749; 
-x_722 = lean_ctor_get(x_719, 1);
-lean_inc(x_722);
-lean_dec(x_719);
-x_746 = lean_st_ref_get(x_6, x_722);
-x_747 = lean_ctor_get(x_746, 0);
-lean_inc(x_747);
-x_748 = lean_ctor_get(x_747, 3);
-lean_inc(x_748);
-lean_dec(x_747);
-x_749 = lean_ctor_get_uint8(x_748, sizeof(void*)*1);
-lean_dec(x_748);
-if (x_749 == 0)
-{
-lean_object* x_750; uint8_t x_751; 
-x_750 = lean_ctor_get(x_746, 1);
+lean_object* x_725; uint8_t x_726; lean_object* x_727; lean_object* x_749; lean_object* x_750; lean_object* x_751; uint8_t x_752; 
+x_725 = lean_ctor_get(x_722, 1);
+lean_inc(x_725);
+lean_dec(x_722);
+x_749 = lean_st_ref_get(x_6, x_725);
+x_750 = lean_ctor_get(x_749, 0);
 lean_inc(x_750);
-lean_dec(x_746);
-x_751 = 0;
-x_723 = x_751;
-x_724 = x_750;
-goto block_745;
+x_751 = lean_ctor_get(x_750, 3);
+lean_inc(x_751);
+lean_dec(x_750);
+x_752 = lean_ctor_get_uint8(x_751, sizeof(void*)*1);
+lean_dec(x_751);
+if (x_752 == 0)
+{
+lean_object* x_753; uint8_t x_754; 
+x_753 = lean_ctor_get(x_749, 1);
+lean_inc(x_753);
+lean_dec(x_749);
+x_754 = 0;
+x_726 = x_754;
+x_727 = x_753;
+goto block_748;
 }
 else
 {
-lean_object* x_752; lean_object* x_753; lean_object* x_754; lean_object* x_755; lean_object* x_756; uint8_t x_757; 
-x_752 = lean_ctor_get(x_746, 1);
-lean_inc(x_752);
-lean_dec(x_746);
-x_753 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_754 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_753, x_3, x_4, x_5, x_6, x_752);
-x_755 = lean_ctor_get(x_754, 0);
+lean_object* x_755; lean_object* x_756; lean_object* x_757; lean_object* x_758; lean_object* x_759; uint8_t x_760; 
+x_755 = lean_ctor_get(x_749, 1);
 lean_inc(x_755);
-x_756 = lean_ctor_get(x_754, 1);
-lean_inc(x_756);
-lean_dec(x_754);
-x_757 = lean_unbox(x_755);
-lean_dec(x_755);
-x_723 = x_757;
-x_724 = x_756;
-goto block_745;
+lean_dec(x_749);
+x_756 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_757 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_756, x_3, x_4, x_5, x_6, x_755);
+x_758 = lean_ctor_get(x_757, 0);
+lean_inc(x_758);
+x_759 = lean_ctor_get(x_757, 1);
+lean_inc(x_759);
+lean_dec(x_757);
+x_760 = lean_unbox(x_758);
+lean_dec(x_758);
+x_726 = x_760;
+x_727 = x_759;
+goto block_748;
 }
-block_745:
+block_748:
 {
-if (x_723 == 0)
+if (x_726 == 0)
 {
-uint8_t x_725; 
-lean_dec(x_711);
-lean_dec(x_707);
+uint8_t x_728; 
+lean_dec(x_714);
+lean_dec(x_710);
 lean_dec(x_2);
 lean_dec(x_1);
-x_725 = 0;
-x_686 = x_725;
-x_687 = x_724;
-goto block_696;
+x_728 = 0;
+x_689 = x_728;
+x_690 = x_727;
+goto block_699;
 }
 else
 {
-lean_object* x_726; lean_object* x_727; lean_object* x_728; lean_object* x_729; lean_object* x_730; lean_object* x_731; lean_object* x_732; lean_object* x_733; lean_object* x_734; lean_object* x_735; lean_object* x_736; lean_object* x_737; lean_object* x_738; lean_object* x_739; lean_object* x_740; lean_object* x_741; lean_object* x_742; lean_object* x_743; uint8_t x_744; 
-x_726 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_726, 0, x_1);
-x_727 = l_Lean_KernelException_toMessageData___closed__15;
-x_728 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_728, 0, x_727);
-lean_ctor_set(x_728, 1, x_726);
-x_729 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
-x_730 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_730, 0, x_728);
-lean_ctor_set(x_730, 1, x_729);
-x_731 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_731, 0, x_707);
-x_732 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_732, 0, x_730);
-lean_ctor_set(x_732, 1, x_731);
-x_733 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_734 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_734, 0, x_732);
-lean_ctor_set(x_734, 1, x_733);
-x_735 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_735, 0, x_2);
-x_736 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_736, 0, x_734);
-lean_ctor_set(x_736, 1, x_735);
+lean_object* x_729; lean_object* x_730; lean_object* x_731; lean_object* x_732; lean_object* x_733; lean_object* x_734; lean_object* x_735; lean_object* x_736; lean_object* x_737; lean_object* x_738; lean_object* x_739; lean_object* x_740; lean_object* x_741; lean_object* x_742; lean_object* x_743; lean_object* x_744; lean_object* x_745; lean_object* x_746; uint8_t x_747; 
+x_729 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_729, 0, x_1);
+x_730 = l_Lean_KernelException_toMessageData___closed__15;
+x_731 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_731, 0, x_730);
+lean_ctor_set(x_731, 1, x_729);
+x_732 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
+x_733 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_733, 0, x_731);
+lean_ctor_set(x_733, 1, x_732);
+x_734 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_734, 0, x_710);
+x_735 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_735, 0, x_733);
+lean_ctor_set(x_735, 1, x_734);
+x_736 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
 x_737 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_737, 0, x_736);
-lean_ctor_set(x_737, 1, x_729);
+lean_ctor_set(x_737, 0, x_735);
+lean_ctor_set(x_737, 1, x_736);
 x_738 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_738, 0, x_711);
+lean_ctor_set(x_738, 0, x_2);
 x_739 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_739, 0, x_737);
 lean_ctor_set(x_739, 1, x_738);
 x_740 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_740, 0, x_739);
-lean_ctor_set(x_740, 1, x_727);
-x_741 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_742 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_741, x_740, x_3, x_4, x_5, x_6, x_724);
-x_743 = lean_ctor_get(x_742, 1);
-lean_inc(x_743);
-lean_dec(x_742);
-x_744 = 0;
-x_686 = x_744;
-x_687 = x_743;
-goto block_696;
+lean_ctor_set(x_740, 1, x_732);
+x_741 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_741, 0, x_714);
+x_742 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_742, 0, x_740);
+lean_ctor_set(x_742, 1, x_741);
+x_743 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_743, 0, x_742);
+lean_ctor_set(x_743, 1, x_730);
+x_744 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_745 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_744, x_743, x_3, x_4, x_5, x_6, x_727);
+x_746 = lean_ctor_get(x_745, 1);
+lean_inc(x_746);
+lean_dec(x_745);
+x_747 = 0;
+x_689 = x_747;
+x_690 = x_746;
+goto block_699;
 }
 }
 }
 else
 {
-lean_object* x_758; uint8_t x_759; lean_object* x_760; lean_object* x_781; lean_object* x_782; lean_object* x_783; uint8_t x_784; 
-lean_dec(x_711);
-lean_dec(x_707);
-x_758 = lean_ctor_get(x_719, 1);
-lean_inc(x_758);
-lean_dec(x_719);
-x_781 = lean_st_ref_get(x_6, x_758);
-x_782 = lean_ctor_get(x_781, 0);
-lean_inc(x_782);
-x_783 = lean_ctor_get(x_782, 3);
-lean_inc(x_783);
-lean_dec(x_782);
-x_784 = lean_ctor_get_uint8(x_783, sizeof(void*)*1);
-lean_dec(x_783);
-if (x_784 == 0)
-{
-lean_object* x_785; uint8_t x_786; 
-x_785 = lean_ctor_get(x_781, 1);
+lean_object* x_761; uint8_t x_762; lean_object* x_763; lean_object* x_784; lean_object* x_785; lean_object* x_786; uint8_t x_787; 
+lean_dec(x_714);
+lean_dec(x_710);
+x_761 = lean_ctor_get(x_722, 1);
+lean_inc(x_761);
+lean_dec(x_722);
+x_784 = lean_st_ref_get(x_6, x_761);
+x_785 = lean_ctor_get(x_784, 0);
 lean_inc(x_785);
-lean_dec(x_781);
-x_786 = 0;
-x_759 = x_786;
-x_760 = x_785;
-goto block_780;
+x_786 = lean_ctor_get(x_785, 3);
+lean_inc(x_786);
+lean_dec(x_785);
+x_787 = lean_ctor_get_uint8(x_786, sizeof(void*)*1);
+lean_dec(x_786);
+if (x_787 == 0)
+{
+lean_object* x_788; uint8_t x_789; 
+x_788 = lean_ctor_get(x_784, 1);
+lean_inc(x_788);
+lean_dec(x_784);
+x_789 = 0;
+x_762 = x_789;
+x_763 = x_788;
+goto block_783;
 }
 else
 {
-lean_object* x_787; lean_object* x_788; lean_object* x_789; lean_object* x_790; lean_object* x_791; uint8_t x_792; 
-x_787 = lean_ctor_get(x_781, 1);
-lean_inc(x_787);
-lean_dec(x_781);
-x_788 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_789 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_788, x_3, x_4, x_5, x_6, x_787);
-x_790 = lean_ctor_get(x_789, 0);
+lean_object* x_790; lean_object* x_791; lean_object* x_792; lean_object* x_793; lean_object* x_794; uint8_t x_795; 
+x_790 = lean_ctor_get(x_784, 1);
 lean_inc(x_790);
-x_791 = lean_ctor_get(x_789, 1);
-lean_inc(x_791);
-lean_dec(x_789);
-x_792 = lean_unbox(x_790);
-lean_dec(x_790);
-x_759 = x_792;
-x_760 = x_791;
-goto block_780;
+lean_dec(x_784);
+x_791 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_792 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_791, x_3, x_4, x_5, x_6, x_790);
+x_793 = lean_ctor_get(x_792, 0);
+lean_inc(x_793);
+x_794 = lean_ctor_get(x_792, 1);
+lean_inc(x_794);
+lean_dec(x_792);
+x_795 = lean_unbox(x_793);
+lean_dec(x_793);
+x_762 = x_795;
+x_763 = x_794;
+goto block_783;
 }
-block_780:
+block_783:
 {
-if (x_759 == 0)
+if (x_762 == 0)
 {
-lean_object* x_761; lean_object* x_762; lean_object* x_763; uint8_t x_764; 
-x_761 = l_Lean_Expr_mvarId_x21(x_1);
+lean_object* x_764; lean_object* x_765; lean_object* x_766; uint8_t x_767; 
+x_764 = l_Lean_Expr_mvarId_x21(x_1);
 lean_dec(x_1);
-x_762 = l_Lean_Meta_assignExprMVar(x_761, x_2, x_3, x_4, x_5, x_6, x_760);
-x_763 = lean_ctor_get(x_762, 1);
-lean_inc(x_763);
-lean_dec(x_762);
-x_764 = 1;
-x_686 = x_764;
-x_687 = x_763;
-goto block_696;
+x_765 = l_Lean_Meta_assignExprMVar(x_764, x_2, x_3, x_4, x_5, x_6, x_763);
+x_766 = lean_ctor_get(x_765, 1);
+lean_inc(x_766);
+lean_dec(x_765);
+x_767 = 1;
+x_689 = x_767;
+x_690 = x_766;
+goto block_699;
 }
 else
 {
-lean_object* x_765; lean_object* x_766; lean_object* x_767; lean_object* x_768; lean_object* x_769; lean_object* x_770; lean_object* x_771; lean_object* x_772; lean_object* x_773; lean_object* x_774; lean_object* x_775; lean_object* x_776; lean_object* x_777; lean_object* x_778; uint8_t x_779; 
+lean_object* x_768; lean_object* x_769; lean_object* x_770; lean_object* x_771; lean_object* x_772; lean_object* x_773; lean_object* x_774; lean_object* x_775; lean_object* x_776; lean_object* x_777; lean_object* x_778; lean_object* x_779; lean_object* x_780; lean_object* x_781; uint8_t x_782; 
 lean_inc(x_1);
-x_765 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_765, 0, x_1);
-x_766 = l_Lean_KernelException_toMessageData___closed__15;
-x_767 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_767, 0, x_766);
-lean_ctor_set(x_767, 1, x_765);
-x_768 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_769 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_769, 0, x_767);
-lean_ctor_set(x_769, 1, x_768);
-lean_inc(x_2);
-x_770 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_770, 0, x_2);
-x_771 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_771, 0, x_769);
-lean_ctor_set(x_771, 1, x_770);
+x_768 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_768, 0, x_1);
+x_769 = l_Lean_KernelException_toMessageData___closed__15;
+x_770 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_770, 0, x_769);
+lean_ctor_set(x_770, 1, x_768);
+x_771 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
 x_772 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_772, 0, x_771);
-lean_ctor_set(x_772, 1, x_766);
-x_773 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_774 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_773, x_772, x_3, x_4, x_5, x_6, x_760);
-x_775 = lean_ctor_get(x_774, 1);
-lean_inc(x_775);
-lean_dec(x_774);
-x_776 = l_Lean_Expr_mvarId_x21(x_1);
-lean_dec(x_1);
-x_777 = l_Lean_Meta_assignExprMVar(x_776, x_2, x_3, x_4, x_5, x_6, x_775);
+lean_ctor_set(x_772, 0, x_770);
+lean_ctor_set(x_772, 1, x_771);
+lean_inc(x_2);
+x_773 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_773, 0, x_2);
+x_774 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_774, 0, x_772);
+lean_ctor_set(x_774, 1, x_773);
+x_775 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_775, 0, x_774);
+lean_ctor_set(x_775, 1, x_769);
+x_776 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_777 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_776, x_775, x_3, x_4, x_5, x_6, x_763);
 x_778 = lean_ctor_get(x_777, 1);
 lean_inc(x_778);
 lean_dec(x_777);
-x_779 = 1;
-x_686 = x_779;
-x_687 = x_778;
-goto block_696;
+x_779 = l_Lean_Expr_mvarId_x21(x_1);
+lean_dec(x_1);
+x_780 = l_Lean_Meta_assignExprMVar(x_779, x_2, x_3, x_4, x_5, x_6, x_778);
+x_781 = lean_ctor_get(x_780, 1);
+lean_inc(x_781);
+lean_dec(x_780);
+x_782 = 1;
+x_689 = x_782;
+x_690 = x_781;
+goto block_699;
 }
 }
 }
 }
 else
 {
-lean_object* x_793; lean_object* x_794; 
-lean_dec(x_711);
-lean_dec(x_707);
+lean_object* x_796; lean_object* x_797; 
+lean_dec(x_714);
+lean_dec(x_710);
 lean_dec(x_2);
 lean_dec(x_1);
-x_793 = lean_ctor_get(x_719, 0);
-lean_inc(x_793);
-x_794 = lean_ctor_get(x_719, 1);
-lean_inc(x_794);
-lean_dec(x_719);
-x_697 = x_793;
-x_698 = x_794;
-goto block_705;
+x_796 = lean_ctor_get(x_722, 0);
+lean_inc(x_796);
+x_797 = lean_ctor_get(x_722, 1);
+lean_inc(x_797);
+lean_dec(x_722);
+x_700 = x_796;
+x_701 = x_797;
+goto block_708;
 }
 }
 else
 {
-uint8_t x_795; uint8_t x_796; uint8_t x_797; uint8_t x_798; uint8_t x_799; uint8_t x_800; uint8_t x_801; uint8_t x_802; uint8_t x_803; lean_object* x_804; lean_object* x_805; lean_object* x_806; 
-x_795 = lean_ctor_get_uint8(x_710, 0);
-x_796 = lean_ctor_get_uint8(x_710, 1);
-x_797 = lean_ctor_get_uint8(x_710, 2);
-x_798 = lean_ctor_get_uint8(x_710, 3);
-x_799 = lean_ctor_get_uint8(x_710, 4);
-x_800 = lean_ctor_get_uint8(x_710, 6);
-x_801 = lean_ctor_get_uint8(x_710, 7);
-x_802 = lean_ctor_get_uint8(x_710, 8);
-lean_dec(x_710);
-x_803 = 1;
-x_804 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_804, 0, x_795);
-lean_ctor_set_uint8(x_804, 1, x_796);
-lean_ctor_set_uint8(x_804, 2, x_797);
-lean_ctor_set_uint8(x_804, 3, x_798);
-lean_ctor_set_uint8(x_804, 4, x_799);
-lean_ctor_set_uint8(x_804, 5, x_803);
-lean_ctor_set_uint8(x_804, 6, x_800);
-lean_ctor_set_uint8(x_804, 7, x_801);
-lean_ctor_set_uint8(x_804, 8, x_802);
-x_805 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_805, 0, x_804);
-lean_ctor_set(x_805, 1, x_713);
-lean_ctor_set(x_805, 2, x_714);
-lean_ctor_set(x_805, 3, x_715);
+uint8_t x_798; uint8_t x_799; uint8_t x_800; uint8_t x_801; uint8_t x_802; uint8_t x_803; uint8_t x_804; uint8_t x_805; uint8_t x_806; uint8_t x_807; lean_object* x_808; lean_object* x_809; lean_object* x_810; 
+x_798 = lean_ctor_get_uint8(x_713, 0);
+x_799 = lean_ctor_get_uint8(x_713, 1);
+x_800 = lean_ctor_get_uint8(x_713, 2);
+x_801 = lean_ctor_get_uint8(x_713, 3);
+x_802 = lean_ctor_get_uint8(x_713, 4);
+x_803 = lean_ctor_get_uint8(x_713, 6);
+x_804 = lean_ctor_get_uint8(x_713, 7);
+x_805 = lean_ctor_get_uint8(x_713, 8);
+x_806 = lean_ctor_get_uint8(x_713, 9);
+lean_dec(x_713);
+x_807 = 1;
+x_808 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_808, 0, x_798);
+lean_ctor_set_uint8(x_808, 1, x_799);
+lean_ctor_set_uint8(x_808, 2, x_800);
+lean_ctor_set_uint8(x_808, 3, x_801);
+lean_ctor_set_uint8(x_808, 4, x_802);
+lean_ctor_set_uint8(x_808, 5, x_807);
+lean_ctor_set_uint8(x_808, 6, x_803);
+lean_ctor_set_uint8(x_808, 7, x_804);
+lean_ctor_set_uint8(x_808, 8, x_805);
+lean_ctor_set_uint8(x_808, 9, x_806);
+x_809 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_809, 0, x_808);
+lean_ctor_set(x_809, 1, x_716);
+lean_ctor_set(x_809, 2, x_717);
+lean_ctor_set(x_809, 3, x_718);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_711);
-lean_inc(x_707);
-x_806 = l_Lean_Meta_isExprDefEqAux(x_707, x_711, x_805, x_4, x_5, x_6, x_712);
-if (lean_obj_tag(x_806) == 0)
+lean_inc(x_714);
+lean_inc(x_710);
+x_810 = l_Lean_Meta_isExprDefEqAux(x_710, x_714, x_809, x_4, x_5, x_6, x_715);
+if (lean_obj_tag(x_810) == 0)
 {
-lean_object* x_807; uint8_t x_808; 
-x_807 = lean_ctor_get(x_806, 0);
-lean_inc(x_807);
-x_808 = lean_unbox(x_807);
-lean_dec(x_807);
-if (x_808 == 0)
+lean_object* x_811; uint8_t x_812; 
+x_811 = lean_ctor_get(x_810, 0);
+lean_inc(x_811);
+x_812 = lean_unbox(x_811);
+lean_dec(x_811);
+if (x_812 == 0)
 {
-lean_object* x_809; uint8_t x_810; lean_object* x_811; lean_object* x_833; lean_object* x_834; lean_object* x_835; uint8_t x_836; 
-x_809 = lean_ctor_get(x_806, 1);
-lean_inc(x_809);
-lean_dec(x_806);
-x_833 = lean_st_ref_get(x_6, x_809);
-x_834 = lean_ctor_get(x_833, 0);
-lean_inc(x_834);
-x_835 = lean_ctor_get(x_834, 3);
-lean_inc(x_835);
-lean_dec(x_834);
-x_836 = lean_ctor_get_uint8(x_835, sizeof(void*)*1);
-lean_dec(x_835);
-if (x_836 == 0)
+lean_object* x_813; uint8_t x_814; lean_object* x_815; lean_object* x_837; lean_object* x_838; lean_object* x_839; uint8_t x_840; 
+x_813 = lean_ctor_get(x_810, 1);
+lean_inc(x_813);
+lean_dec(x_810);
+x_837 = lean_st_ref_get(x_6, x_813);
+x_838 = lean_ctor_get(x_837, 0);
+lean_inc(x_838);
+x_839 = lean_ctor_get(x_838, 3);
+lean_inc(x_839);
+lean_dec(x_838);
+x_840 = lean_ctor_get_uint8(x_839, sizeof(void*)*1);
+lean_dec(x_839);
+if (x_840 == 0)
 {
-lean_object* x_837; uint8_t x_838; 
-x_837 = lean_ctor_get(x_833, 1);
-lean_inc(x_837);
-lean_dec(x_833);
-x_838 = 0;
-x_810 = x_838;
-x_811 = x_837;
-goto block_832;
+lean_object* x_841; uint8_t x_842; 
+x_841 = lean_ctor_get(x_837, 1);
+lean_inc(x_841);
+lean_dec(x_837);
+x_842 = 0;
+x_814 = x_842;
+x_815 = x_841;
+goto block_836;
 }
 else
 {
-lean_object* x_839; lean_object* x_840; lean_object* x_841; lean_object* x_842; lean_object* x_843; uint8_t x_844; 
-x_839 = lean_ctor_get(x_833, 1);
-lean_inc(x_839);
-lean_dec(x_833);
-x_840 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_841 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_840, x_3, x_4, x_5, x_6, x_839);
-x_842 = lean_ctor_get(x_841, 0);
-lean_inc(x_842);
-x_843 = lean_ctor_get(x_841, 1);
+lean_object* x_843; lean_object* x_844; lean_object* x_845; lean_object* x_846; lean_object* x_847; uint8_t x_848; 
+x_843 = lean_ctor_get(x_837, 1);
 lean_inc(x_843);
-lean_dec(x_841);
-x_844 = lean_unbox(x_842);
-lean_dec(x_842);
-x_810 = x_844;
-x_811 = x_843;
-goto block_832;
+lean_dec(x_837);
+x_844 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_845 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_844, x_3, x_4, x_5, x_6, x_843);
+x_846 = lean_ctor_get(x_845, 0);
+lean_inc(x_846);
+x_847 = lean_ctor_get(x_845, 1);
+lean_inc(x_847);
+lean_dec(x_845);
+x_848 = lean_unbox(x_846);
+lean_dec(x_846);
+x_814 = x_848;
+x_815 = x_847;
+goto block_836;
 }
-block_832:
+block_836:
 {
-if (x_810 == 0)
+if (x_814 == 0)
 {
-uint8_t x_812; 
-lean_dec(x_711);
-lean_dec(x_707);
+uint8_t x_816; 
+lean_dec(x_714);
+lean_dec(x_710);
 lean_dec(x_2);
 lean_dec(x_1);
-x_812 = 0;
-x_686 = x_812;
-x_687 = x_811;
-goto block_696;
+x_816 = 0;
+x_689 = x_816;
+x_690 = x_815;
+goto block_699;
 }
 else
 {
-lean_object* x_813; lean_object* x_814; lean_object* x_815; lean_object* x_816; lean_object* x_817; lean_object* x_818; lean_object* x_819; lean_object* x_820; lean_object* x_821; lean_object* x_822; lean_object* x_823; lean_object* x_824; lean_object* x_825; lean_object* x_826; lean_object* x_827; lean_object* x_828; lean_object* x_829; lean_object* x_830; uint8_t x_831; 
-x_813 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_813, 0, x_1);
-x_814 = l_Lean_KernelException_toMessageData___closed__15;
-x_815 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_815, 0, x_814);
-lean_ctor_set(x_815, 1, x_813);
-x_816 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
-x_817 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_817, 0, x_815);
-lean_ctor_set(x_817, 1, x_816);
-x_818 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_818, 0, x_707);
+lean_object* x_817; lean_object* x_818; lean_object* x_819; lean_object* x_820; lean_object* x_821; lean_object* x_822; lean_object* x_823; lean_object* x_824; lean_object* x_825; lean_object* x_826; lean_object* x_827; lean_object* x_828; lean_object* x_829; lean_object* x_830; lean_object* x_831; lean_object* x_832; lean_object* x_833; lean_object* x_834; uint8_t x_835; 
+x_817 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_817, 0, x_1);
+x_818 = l_Lean_KernelException_toMessageData___closed__15;
 x_819 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_819, 0, x_817);
-lean_ctor_set(x_819, 1, x_818);
-x_820 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+lean_ctor_set(x_819, 0, x_818);
+lean_ctor_set(x_819, 1, x_817);
+x_820 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__5;
 x_821 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_821, 0, x_819);
 lean_ctor_set(x_821, 1, x_820);
 x_822 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_822, 0, x_2);
+lean_ctor_set(x_822, 0, x_710);
 x_823 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_823, 0, x_821);
 lean_ctor_set(x_823, 1, x_822);
-x_824 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_824, 0, x_823);
-lean_ctor_set(x_824, 1, x_816);
-x_825 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_825, 0, x_711);
-x_826 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_826, 0, x_824);
-lean_ctor_set(x_826, 1, x_825);
+x_824 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_825 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_825, 0, x_823);
+lean_ctor_set(x_825, 1, x_824);
+x_826 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_826, 0, x_2);
 x_827 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_827, 0, x_826);
-lean_ctor_set(x_827, 1, x_814);
-x_828 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
-x_829 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_828, x_827, x_3, x_4, x_5, x_6, x_811);
-x_830 = lean_ctor_get(x_829, 1);
-lean_inc(x_830);
-lean_dec(x_829);
-x_831 = 0;
-x_686 = x_831;
-x_687 = x_830;
-goto block_696;
+lean_ctor_set(x_827, 0, x_825);
+lean_ctor_set(x_827, 1, x_826);
+x_828 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_828, 0, x_827);
+lean_ctor_set(x_828, 1, x_820);
+x_829 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_829, 0, x_714);
+x_830 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_830, 0, x_828);
+lean_ctor_set(x_830, 1, x_829);
+x_831 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_831, 0, x_830);
+lean_ctor_set(x_831, 1, x_818);
+x_832 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__6;
+x_833 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_832, x_831, x_3, x_4, x_5, x_6, x_815);
+x_834 = lean_ctor_get(x_833, 1);
+lean_inc(x_834);
+lean_dec(x_833);
+x_835 = 0;
+x_689 = x_835;
+x_690 = x_834;
+goto block_699;
 }
 }
 }
 else
 {
-lean_object* x_845; uint8_t x_846; lean_object* x_847; lean_object* x_868; lean_object* x_869; lean_object* x_870; uint8_t x_871; 
-lean_dec(x_711);
-lean_dec(x_707);
-x_845 = lean_ctor_get(x_806, 1);
-lean_inc(x_845);
-lean_dec(x_806);
-x_868 = lean_st_ref_get(x_6, x_845);
-x_869 = lean_ctor_get(x_868, 0);
-lean_inc(x_869);
-x_870 = lean_ctor_get(x_869, 3);
-lean_inc(x_870);
-lean_dec(x_869);
-x_871 = lean_ctor_get_uint8(x_870, sizeof(void*)*1);
-lean_dec(x_870);
-if (x_871 == 0)
-{
-lean_object* x_872; uint8_t x_873; 
-x_872 = lean_ctor_get(x_868, 1);
-lean_inc(x_872);
-lean_dec(x_868);
-x_873 = 0;
-x_846 = x_873;
-x_847 = x_872;
-goto block_867;
-}
-else
-{
-lean_object* x_874; lean_object* x_875; lean_object* x_876; lean_object* x_877; lean_object* x_878; uint8_t x_879; 
-x_874 = lean_ctor_get(x_868, 1);
+lean_object* x_849; uint8_t x_850; lean_object* x_851; lean_object* x_872; lean_object* x_873; lean_object* x_874; uint8_t x_875; 
+lean_dec(x_714);
+lean_dec(x_710);
+x_849 = lean_ctor_get(x_810, 1);
+lean_inc(x_849);
+lean_dec(x_810);
+x_872 = lean_st_ref_get(x_6, x_849);
+x_873 = lean_ctor_get(x_872, 0);
+lean_inc(x_873);
+x_874 = lean_ctor_get(x_873, 3);
 lean_inc(x_874);
-lean_dec(x_868);
-x_875 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_876 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_875, x_3, x_4, x_5, x_6, x_874);
-x_877 = lean_ctor_get(x_876, 0);
-lean_inc(x_877);
-x_878 = lean_ctor_get(x_876, 1);
+lean_dec(x_873);
+x_875 = lean_ctor_get_uint8(x_874, sizeof(void*)*1);
+lean_dec(x_874);
+if (x_875 == 0)
+{
+lean_object* x_876; uint8_t x_877; 
+x_876 = lean_ctor_get(x_872, 1);
+lean_inc(x_876);
+lean_dec(x_872);
+x_877 = 0;
+x_850 = x_877;
+x_851 = x_876;
+goto block_871;
+}
+else
+{
+lean_object* x_878; lean_object* x_879; lean_object* x_880; lean_object* x_881; lean_object* x_882; uint8_t x_883; 
+x_878 = lean_ctor_get(x_872, 1);
 lean_inc(x_878);
-lean_dec(x_876);
-x_879 = lean_unbox(x_877);
-lean_dec(x_877);
-x_846 = x_879;
-x_847 = x_878;
-goto block_867;
-}
-block_867:
-{
-if (x_846 == 0)
-{
-lean_object* x_848; lean_object* x_849; lean_object* x_850; uint8_t x_851; 
-x_848 = l_Lean_Expr_mvarId_x21(x_1);
-lean_dec(x_1);
-x_849 = l_Lean_Meta_assignExprMVar(x_848, x_2, x_3, x_4, x_5, x_6, x_847);
-x_850 = lean_ctor_get(x_849, 1);
-lean_inc(x_850);
-lean_dec(x_849);
-x_851 = 1;
-x_686 = x_851;
-x_687 = x_850;
-goto block_696;
-}
-else
-{
-lean_object* x_852; lean_object* x_853; lean_object* x_854; lean_object* x_855; lean_object* x_856; lean_object* x_857; lean_object* x_858; lean_object* x_859; lean_object* x_860; lean_object* x_861; lean_object* x_862; lean_object* x_863; lean_object* x_864; lean_object* x_865; uint8_t x_866; 
-lean_inc(x_1);
-x_852 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_852, 0, x_1);
-x_853 = l_Lean_KernelException_toMessageData___closed__15;
-x_854 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_854, 0, x_853);
-lean_ctor_set(x_854, 1, x_852);
-x_855 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_856 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_856, 0, x_854);
-lean_ctor_set(x_856, 1, x_855);
-lean_inc(x_2);
-x_857 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_857, 0, x_2);
-x_858 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_858, 0, x_856);
-lean_ctor_set(x_858, 1, x_857);
-x_859 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_859, 0, x_858);
-lean_ctor_set(x_859, 1, x_853);
-x_860 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_861 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_860, x_859, x_3, x_4, x_5, x_6, x_847);
-x_862 = lean_ctor_get(x_861, 1);
-lean_inc(x_862);
-lean_dec(x_861);
-x_863 = l_Lean_Expr_mvarId_x21(x_1);
-lean_dec(x_1);
-x_864 = l_Lean_Meta_assignExprMVar(x_863, x_2, x_3, x_4, x_5, x_6, x_862);
-x_865 = lean_ctor_get(x_864, 1);
-lean_inc(x_865);
-lean_dec(x_864);
-x_866 = 1;
-x_686 = x_866;
-x_687 = x_865;
-goto block_696;
-}
-}
-}
-}
-else
-{
-lean_object* x_880; lean_object* x_881; 
-lean_dec(x_711);
-lean_dec(x_707);
-lean_dec(x_2);
-lean_dec(x_1);
-x_880 = lean_ctor_get(x_806, 0);
-lean_inc(x_880);
-x_881 = lean_ctor_get(x_806, 1);
+lean_dec(x_872);
+x_879 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_880 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_879, x_3, x_4, x_5, x_6, x_878);
+x_881 = lean_ctor_get(x_880, 0);
 lean_inc(x_881);
-lean_dec(x_806);
-x_697 = x_880;
-x_698 = x_881;
-goto block_705;
-}
+x_882 = lean_ctor_get(x_880, 1);
+lean_inc(x_882);
+lean_dec(x_880);
+x_883 = lean_unbox(x_881);
+lean_dec(x_881);
+x_850 = x_883;
+x_851 = x_882;
+goto block_871;
 }
+block_871:
+{
+if (x_850 == 0)
+{
+lean_object* x_852; lean_object* x_853; lean_object* x_854; uint8_t x_855; 
+x_852 = l_Lean_Expr_mvarId_x21(x_1);
+lean_dec(x_1);
+x_853 = l_Lean_Meta_assignExprMVar(x_852, x_2, x_3, x_4, x_5, x_6, x_851);
+x_854 = lean_ctor_get(x_853, 1);
+lean_inc(x_854);
+lean_dec(x_853);
+x_855 = 1;
+x_689 = x_855;
+x_690 = x_854;
+goto block_699;
 }
 else
 {
-lean_object* x_882; lean_object* x_883; 
-lean_dec(x_707);
-lean_dec(x_2);
+lean_object* x_856; lean_object* x_857; lean_object* x_858; lean_object* x_859; lean_object* x_860; lean_object* x_861; lean_object* x_862; lean_object* x_863; lean_object* x_864; lean_object* x_865; lean_object* x_866; lean_object* x_867; lean_object* x_868; lean_object* x_869; uint8_t x_870; 
+lean_inc(x_1);
+x_856 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_856, 0, x_1);
+x_857 = l_Lean_KernelException_toMessageData___closed__15;
+x_858 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_858, 0, x_857);
+lean_ctor_set(x_858, 1, x_856);
+x_859 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
+x_860 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_860, 0, x_858);
+lean_ctor_set(x_860, 1, x_859);
+lean_inc(x_2);
+x_861 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_861, 0, x_2);
+x_862 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_862, 0, x_860);
+lean_ctor_set(x_862, 1, x_861);
+x_863 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_863, 0, x_862);
+lean_ctor_set(x_863, 1, x_857);
+x_864 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_865 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_864, x_863, x_3, x_4, x_5, x_6, x_851);
+x_866 = lean_ctor_get(x_865, 1);
+lean_inc(x_866);
+lean_dec(x_865);
+x_867 = l_Lean_Expr_mvarId_x21(x_1);
 lean_dec(x_1);
-x_882 = lean_ctor_get(x_709, 0);
-lean_inc(x_882);
-x_883 = lean_ctor_get(x_709, 1);
-lean_inc(x_883);
-lean_dec(x_709);
-x_697 = x_882;
-x_698 = x_883;
-goto block_705;
+x_868 = l_Lean_Meta_assignExprMVar(x_867, x_2, x_3, x_4, x_5, x_6, x_866);
+x_869 = lean_ctor_get(x_868, 1);
+lean_inc(x_869);
+lean_dec(x_868);
+x_870 = 1;
+x_689 = x_870;
+x_690 = x_869;
+goto block_699;
+}
+}
 }
 }
 else
 {
 lean_object* x_884; lean_object* x_885; 
+lean_dec(x_714);
+lean_dec(x_710);
 lean_dec(x_2);
 lean_dec(x_1);
-x_884 = lean_ctor_get(x_706, 0);
+x_884 = lean_ctor_get(x_810, 0);
 lean_inc(x_884);
-x_885 = lean_ctor_get(x_706, 1);
+x_885 = lean_ctor_get(x_810, 1);
 lean_inc(x_885);
-lean_dec(x_706);
-x_697 = x_884;
-x_698 = x_885;
-goto block_705;
+lean_dec(x_810);
+x_700 = x_884;
+x_701 = x_885;
+goto block_708;
+}
 }
 }
 else
 {
-uint8_t x_886; lean_object* x_887; lean_object* x_903; lean_object* x_904; lean_object* x_905; uint8_t x_906; 
-x_903 = lean_st_ref_get(x_6, x_685);
-x_904 = lean_ctor_get(x_903, 0);
-lean_inc(x_904);
-x_905 = lean_ctor_get(x_904, 3);
-lean_inc(x_905);
-lean_dec(x_904);
-x_906 = lean_ctor_get_uint8(x_905, sizeof(void*)*1);
-lean_dec(x_905);
-if (x_906 == 0)
-{
-lean_object* x_907; uint8_t x_908; 
-x_907 = lean_ctor_get(x_903, 1);
-lean_inc(x_907);
-lean_dec(x_903);
-x_908 = 0;
-x_886 = x_908;
-x_887 = x_907;
-goto block_902;
-}
-else
-{
-lean_object* x_909; lean_object* x_910; lean_object* x_911; lean_object* x_912; lean_object* x_913; uint8_t x_914; 
-x_909 = lean_ctor_get(x_903, 1);
-lean_inc(x_909);
-lean_dec(x_903);
-x_910 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_911 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_910, x_3, x_4, x_5, x_6, x_909);
-x_912 = lean_ctor_get(x_911, 0);
-lean_inc(x_912);
-x_913 = lean_ctor_get(x_911, 1);
-lean_inc(x_913);
-lean_dec(x_911);
-x_914 = lean_unbox(x_912);
-lean_dec(x_912);
-x_886 = x_914;
-x_887 = x_913;
-goto block_902;
-}
-block_902:
-{
-if (x_886 == 0)
-{
-uint8_t x_888; 
+lean_object* x_886; lean_object* x_887; 
+lean_dec(x_710);
 lean_dec(x_2);
 lean_dec(x_1);
-x_888 = 0;
-x_686 = x_888;
-x_687 = x_887;
-goto block_696;
+x_886 = lean_ctor_get(x_712, 0);
+lean_inc(x_886);
+x_887 = lean_ctor_get(x_712, 1);
+lean_inc(x_887);
+lean_dec(x_712);
+x_700 = x_886;
+x_701 = x_887;
+goto block_708;
+}
 }
 else
 {
-lean_object* x_889; lean_object* x_890; lean_object* x_891; lean_object* x_892; lean_object* x_893; lean_object* x_894; lean_object* x_895; lean_object* x_896; lean_object* x_897; lean_object* x_898; lean_object* x_899; lean_object* x_900; uint8_t x_901; 
-x_889 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_889, 0, x_1);
-x_890 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
-x_891 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_891, 0, x_890);
-lean_ctor_set(x_891, 1, x_889);
-x_892 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-x_893 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_893, 0, x_891);
-lean_ctor_set(x_893, 1, x_892);
-x_894 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_894, 0, x_2);
+lean_object* x_888; lean_object* x_889; 
+lean_dec(x_2);
+lean_dec(x_1);
+x_888 = lean_ctor_get(x_709, 0);
+lean_inc(x_888);
+x_889 = lean_ctor_get(x_709, 1);
+lean_inc(x_889);
+lean_dec(x_709);
+x_700 = x_888;
+x_701 = x_889;
+goto block_708;
+}
+}
+else
+{
+uint8_t x_890; lean_object* x_891; lean_object* x_907; lean_object* x_908; lean_object* x_909; uint8_t x_910; 
+x_907 = lean_st_ref_get(x_6, x_688);
+x_908 = lean_ctor_get(x_907, 0);
+lean_inc(x_908);
+x_909 = lean_ctor_get(x_908, 3);
+lean_inc(x_909);
+lean_dec(x_908);
+x_910 = lean_ctor_get_uint8(x_909, sizeof(void*)*1);
+lean_dec(x_909);
+if (x_910 == 0)
+{
+lean_object* x_911; uint8_t x_912; 
+x_911 = lean_ctor_get(x_907, 1);
+lean_inc(x_911);
+lean_dec(x_907);
+x_912 = 0;
+x_890 = x_912;
+x_891 = x_911;
+goto block_906;
+}
+else
+{
+lean_object* x_913; lean_object* x_914; lean_object* x_915; lean_object* x_916; lean_object* x_917; uint8_t x_918; 
+x_913 = lean_ctor_get(x_907, 1);
+lean_inc(x_913);
+lean_dec(x_907);
+x_914 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_915 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_914, x_3, x_4, x_5, x_6, x_913);
+x_916 = lean_ctor_get(x_915, 0);
+lean_inc(x_916);
+x_917 = lean_ctor_get(x_915, 1);
+lean_inc(x_917);
+lean_dec(x_915);
+x_918 = lean_unbox(x_916);
+lean_dec(x_916);
+x_890 = x_918;
+x_891 = x_917;
+goto block_906;
+}
+block_906:
+{
+if (x_890 == 0)
+{
+uint8_t x_892; 
+lean_dec(x_2);
+lean_dec(x_1);
+x_892 = 0;
+x_689 = x_892;
+x_690 = x_891;
+goto block_699;
+}
+else
+{
+lean_object* x_893; lean_object* x_894; lean_object* x_895; lean_object* x_896; lean_object* x_897; lean_object* x_898; lean_object* x_899; lean_object* x_900; lean_object* x_901; lean_object* x_902; lean_object* x_903; lean_object* x_904; uint8_t x_905; 
+x_893 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_893, 0, x_1);
+x_894 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__11;
 x_895 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_895, 0, x_893);
-lean_ctor_set(x_895, 1, x_894);
-x_896 = l_Lean_KernelException_toMessageData___closed__15;
+lean_ctor_set(x_895, 0, x_894);
+lean_ctor_set(x_895, 1, x_893);
+x_896 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
 x_897 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_897, 0, x_895);
 lean_ctor_set(x_897, 1, x_896);
-x_898 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
-x_899 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_898, x_897, x_3, x_4, x_5, x_6, x_887);
-x_900 = lean_ctor_get(x_899, 1);
-lean_inc(x_900);
-lean_dec(x_899);
-x_901 = 0;
-x_686 = x_901;
-x_687 = x_900;
-goto block_696;
+x_898 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_898, 0, x_2);
+x_899 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_899, 0, x_897);
+lean_ctor_set(x_899, 1, x_898);
+x_900 = l_Lean_KernelException_toMessageData___closed__15;
+x_901 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_901, 0, x_899);
+lean_ctor_set(x_901, 1, x_900);
+x_902 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__9;
+x_903 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_902, x_901, x_3, x_4, x_5, x_6, x_891);
+x_904 = lean_ctor_get(x_903, 1);
+lean_inc(x_904);
+lean_dec(x_903);
+x_905 = 0;
+x_689 = x_905;
+x_690 = x_904;
+goto block_699;
 }
 }
 }
-block_696:
+block_699:
 {
-lean_object* x_688; lean_object* x_689; uint8_t x_690; 
-x_688 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__4;
-x_689 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_684, x_688, x_682, x_3, x_4, x_5, x_6, x_687);
+lean_object* x_691; lean_object* x_692; uint8_t x_693; 
+x_691 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__4;
+x_692 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_687, x_691, x_685, x_3, x_4, x_5, x_6, x_690);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_690 = !lean_is_exclusive(x_689);
-if (x_690 == 0)
+x_693 = !lean_is_exclusive(x_692);
+if (x_693 == 0)
 {
-lean_object* x_691; lean_object* x_692; 
-x_691 = lean_ctor_get(x_689, 0);
-lean_dec(x_691);
-x_692 = lean_box(x_686);
-lean_ctor_set(x_689, 0, x_692);
-return x_689;
+lean_object* x_694; lean_object* x_695; 
+x_694 = lean_ctor_get(x_692, 0);
+lean_dec(x_694);
+x_695 = lean_box(x_689);
+lean_ctor_set(x_692, 0, x_695);
+return x_692;
 }
 else
 {
-lean_object* x_693; lean_object* x_694; lean_object* x_695; 
-x_693 = lean_ctor_get(x_689, 1);
-lean_inc(x_693);
-lean_dec(x_689);
-x_694 = lean_box(x_686);
-x_695 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_695, 0, x_694);
-lean_ctor_set(x_695, 1, x_693);
-return x_695;
+lean_object* x_696; lean_object* x_697; lean_object* x_698; 
+x_696 = lean_ctor_get(x_692, 1);
+lean_inc(x_696);
+lean_dec(x_692);
+x_697 = lean_box(x_689);
+x_698 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_698, 0, x_697);
+lean_ctor_set(x_698, 1, x_696);
+return x_698;
 }
 }
-block_705:
+block_708:
 {
-lean_object* x_699; lean_object* x_700; uint8_t x_701; 
-x_699 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__4;
-x_700 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_684, x_699, x_682, x_3, x_4, x_5, x_6, x_698);
+lean_object* x_702; lean_object* x_703; uint8_t x_704; 
+x_702 = l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__4;
+x_703 = l___private_Lean_Util_Trace_0__Lean_addNode___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__12(x_687, x_702, x_685, x_3, x_4, x_5, x_6, x_701);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_701 = !lean_is_exclusive(x_700);
-if (x_701 == 0)
+x_704 = !lean_is_exclusive(x_703);
+if (x_704 == 0)
 {
-lean_object* x_702; 
-x_702 = lean_ctor_get(x_700, 0);
-lean_dec(x_702);
-lean_ctor_set_tag(x_700, 1);
-lean_ctor_set(x_700, 0, x_697);
-return x_700;
+lean_object* x_705; 
+x_705 = lean_ctor_get(x_703, 0);
+lean_dec(x_705);
+lean_ctor_set_tag(x_703, 1);
+lean_ctor_set(x_703, 0, x_700);
+return x_703;
 }
 else
 {
-lean_object* x_703; lean_object* x_704; 
-x_703 = lean_ctor_get(x_700, 1);
-lean_inc(x_703);
-lean_dec(x_700);
-x_704 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_704, 0, x_697);
-lean_ctor_set(x_704, 1, x_703);
-return x_704;
+lean_object* x_706; lean_object* x_707; 
+x_706 = lean_ctor_get(x_703, 1);
+lean_inc(x_706);
+lean_dec(x_703);
+x_707 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_707, 0, x_700);
+lean_ctor_set(x_707, 1, x_706);
+return x_707;
 }
 }
 }
@@ -11632,7 +11646,7 @@ lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean
 x_81 = lean_ctor_get(x_75, 1);
 lean_inc(x_81);
 lean_dec(x_75);
-x_82 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_82 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_83 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_82, x_3, x_4, x_5, x_6, x_81);
 x_84 = lean_ctor_get(x_83, 0);
 lean_inc(x_84);
@@ -11734,7 +11748,7 @@ x_55 = l_Lean_KernelException_toMessageData___closed__15;
 x_56 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_56, 0, x_54);
 lean_ctor_set(x_56, 1, x_55);
-x_57 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_57 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_58 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_57, x_56, x_3, x_4, x_5, x_6, x_31);
 x_59 = lean_ctor_get(x_58, 1);
 lean_inc(x_59);
@@ -47611,19 +47625,13 @@ return x_6;
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_isDefEqProofIrrel(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
-lean_object* x_8; 
-lean_inc(x_3);
-lean_inc(x_1);
-x_8 = l_Lean_Meta_isProofQuick(x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; uint8_t x_10; 
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = l_Lean_Meta_getConfig(x_3, x_4, x_5, x_6, x_7);
 x_9 = lean_ctor_get(x_8, 0);
 lean_inc(x_9);
-x_10 = lean_unbox(x_9);
+x_10 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-switch (x_10) {
-case 0:
+if (x_10 == 0)
 {
 uint8_t x_11; 
 lean_dec(x_6);
@@ -47657,372 +47665,337 @@ lean_ctor_set(x_18, 1, x_15);
 return x_18;
 }
 }
-case 1:
+else
 {
 lean_object* x_19; lean_object* x_20; 
 x_19 = lean_ctor_get(x_8, 1);
 lean_inc(x_19);
 lean_dec(x_8);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
 lean_inc(x_3);
-x_20 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_19);
+lean_inc(x_1);
+x_20 = l_Lean_Meta_isProofQuick(x_1, x_3, x_4, x_5, x_6, x_19);
 if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+lean_object* x_21; uint8_t x_22; 
 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);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_3);
-x_23 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_22);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_23, 1);
-lean_inc(x_25);
-lean_dec(x_23);
-x_26 = l_Lean_Meta_isExprDefEqAux(x_21, x_24, x_3, x_4, x_5, x_6, x_25);
-if (lean_obj_tag(x_26) == 0)
-{
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_26);
-if (x_27 == 0)
-{
-lean_object* x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; 
-x_28 = lean_ctor_get(x_26, 0);
-x_29 = lean_unbox(x_28);
-lean_dec(x_28);
-x_30 = l_Bool_toLBool(x_29);
-x_31 = lean_box(x_30);
-lean_ctor_set(x_26, 0, x_31);
-return x_26;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; uint8_t x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; 
-x_32 = lean_ctor_get(x_26, 0);
-x_33 = lean_ctor_get(x_26, 1);
-lean_inc(x_33);
-lean_inc(x_32);
-lean_dec(x_26);
-x_34 = lean_unbox(x_32);
-lean_dec(x_32);
-x_35 = l_Bool_toLBool(x_34);
-x_36 = lean_box(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_33);
-return x_37;
-}
-}
-else
-{
-uint8_t x_38; 
-x_38 = !lean_is_exclusive(x_26);
-if (x_38 == 0)
-{
-return x_26;
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_39 = lean_ctor_get(x_26, 0);
-x_40 = lean_ctor_get(x_26, 1);
-lean_inc(x_40);
-lean_inc(x_39);
-lean_dec(x_26);
-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_42; 
+x_22 = lean_unbox(x_21);
 lean_dec(x_21);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_42 = !lean_is_exclusive(x_23);
-if (x_42 == 0)
+switch (x_22) {
+case 0:
 {
-return x_23;
-}
-else
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_23, 0);
-x_44 = lean_ctor_get(x_23, 1);
-lean_inc(x_44);
-lean_inc(x_43);
-lean_dec(x_23);
-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
-{
-uint8_t x_46; 
+uint8_t x_23; 
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_46 = !lean_is_exclusive(x_20);
-if (x_46 == 0)
+lean_dec(x_1);
+x_23 = !lean_is_exclusive(x_20);
+if (x_23 == 0)
 {
+lean_object* x_24; uint8_t x_25; lean_object* x_26; 
+x_24 = lean_ctor_get(x_20, 0);
+lean_dec(x_24);
+x_25 = 2;
+x_26 = lean_box(x_25);
+lean_ctor_set(x_20, 0, x_26);
 return x_20;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_47 = lean_ctor_get(x_20, 0);
-x_48 = lean_ctor_get(x_20, 1);
-lean_inc(x_48);
-lean_inc(x_47);
+lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
+x_27 = lean_ctor_get(x_20, 1);
+lean_inc(x_27);
 lean_dec(x_20);
-x_49 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_49, 0, x_47);
-lean_ctor_set(x_49, 1, x_48);
+x_28 = 2;
+x_29 = lean_box(x_28);
+x_30 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_27);
+return x_30;
+}
+}
+case 1:
+{
+lean_object* x_31; lean_object* x_32; 
+x_31 = lean_ctor_get(x_20, 1);
+lean_inc(x_31);
+lean_dec(x_20);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+x_32 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_31);
+if (lean_obj_tag(x_32) == 0)
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_33 = lean_ctor_get(x_32, 0);
+lean_inc(x_33);
+x_34 = lean_ctor_get(x_32, 1);
+lean_inc(x_34);
+lean_dec(x_32);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+x_35 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_34);
+if (lean_obj_tag(x_35) == 0)
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+x_36 = lean_ctor_get(x_35, 0);
+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_isExprDefEqAux(x_33, x_36, x_3, x_4, x_5, x_6, x_37);
+if (lean_obj_tag(x_38) == 0)
+{
+uint8_t x_39; 
+x_39 = !lean_is_exclusive(x_38);
+if (x_39 == 0)
+{
+lean_object* x_40; uint8_t x_41; uint8_t x_42; lean_object* x_43; 
+x_40 = lean_ctor_get(x_38, 0);
+x_41 = lean_unbox(x_40);
+lean_dec(x_40);
+x_42 = l_Bool_toLBool(x_41);
+x_43 = lean_box(x_42);
+lean_ctor_set(x_38, 0, x_43);
+return x_38;
+}
+else
+{
+lean_object* x_44; lean_object* x_45; uint8_t x_46; uint8_t x_47; lean_object* x_48; lean_object* x_49; 
+x_44 = lean_ctor_get(x_38, 0);
+x_45 = lean_ctor_get(x_38, 1);
+lean_inc(x_45);
+lean_inc(x_44);
+lean_dec(x_38);
+x_46 = lean_unbox(x_44);
+lean_dec(x_44);
+x_47 = l_Bool_toLBool(x_46);
+x_48 = lean_box(x_47);
+x_49 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_49, 0, x_48);
+lean_ctor_set(x_49, 1, x_45);
 return x_49;
 }
 }
+else
+{
+uint8_t x_50; 
+x_50 = !lean_is_exclusive(x_38);
+if (x_50 == 0)
+{
+return x_38;
+}
+else
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_51 = lean_ctor_get(x_38, 0);
+x_52 = lean_ctor_get(x_38, 1);
+lean_inc(x_52);
+lean_inc(x_51);
+lean_dec(x_38);
+x_53 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_53, 0, x_51);
+lean_ctor_set(x_53, 1, x_52);
+return x_53;
+}
+}
+}
+else
+{
+uint8_t x_54; 
+lean_dec(x_33);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_54 = !lean_is_exclusive(x_35);
+if (x_54 == 0)
+{
+return x_35;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_55 = lean_ctor_get(x_35, 0);
+x_56 = lean_ctor_get(x_35, 1);
+lean_inc(x_56);
+lean_inc(x_55);
+lean_dec(x_35);
+x_57 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_57, 0, x_55);
+lean_ctor_set(x_57, 1, x_56);
+return x_57;
+}
+}
+}
+else
+{
+uint8_t x_58; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_58 = !lean_is_exclusive(x_32);
+if (x_58 == 0)
+{
+return x_32;
+}
+else
+{
+lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_59 = lean_ctor_get(x_32, 0);
+x_60 = lean_ctor_get(x_32, 1);
+lean_inc(x_60);
+lean_inc(x_59);
+lean_dec(x_32);
+x_61 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_61, 0, x_59);
+lean_ctor_set(x_61, 1, x_60);
+return x_61;
+}
+}
 }
 default: 
 {
-lean_object* x_50; lean_object* x_51; 
-x_50 = lean_ctor_get(x_8, 1);
-lean_inc(x_50);
-lean_dec(x_8);
+lean_object* x_62; lean_object* x_63; 
+x_62 = lean_ctor_get(x_20, 1);
+lean_inc(x_62);
+lean_dec(x_20);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_51 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_50);
-if (lean_obj_tag(x_51) == 0)
+x_63 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_62);
+if (lean_obj_tag(x_63) == 0)
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-x_52 = lean_ctor_get(x_51, 0);
-lean_inc(x_52);
-x_53 = lean_ctor_get(x_51, 1);
-lean_inc(x_53);
-lean_dec(x_51);
+lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_64 = lean_ctor_get(x_63, 0);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_63, 1);
+lean_inc(x_65);
+lean_dec(x_63);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_52);
-x_54 = l_Lean_Meta_isProp(x_52, x_3, x_4, x_5, x_6, x_53);
-if (lean_obj_tag(x_54) == 0)
+lean_inc(x_64);
+x_66 = l_Lean_Meta_isProp(x_64, x_3, x_4, x_5, x_6, x_65);
+if (lean_obj_tag(x_66) == 0)
 {
-lean_object* x_55; uint8_t x_56; 
-x_55 = lean_ctor_get(x_54, 0);
-lean_inc(x_55);
-x_56 = lean_unbox(x_55);
-lean_dec(x_55);
-if (x_56 == 0)
+lean_object* x_67; uint8_t x_68; 
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_unbox(x_67);
+lean_dec(x_67);
+if (x_68 == 0)
 {
-uint8_t x_57; 
-lean_dec(x_52);
+uint8_t x_69; 
+lean_dec(x_64);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_57 = !lean_is_exclusive(x_54);
-if (x_57 == 0)
-{
-lean_object* x_58; uint8_t x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_54, 0);
-lean_dec(x_58);
-x_59 = 2;
-x_60 = lean_box(x_59);
-lean_ctor_set(x_54, 0, x_60);
-return x_54;
-}
-else
-{
-lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = lean_ctor_get(x_54, 1);
-lean_inc(x_61);
-lean_dec(x_54);
-x_62 = 2;
-x_63 = lean_box(x_62);
-x_64 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_64, 0, x_63);
-lean_ctor_set(x_64, 1, x_61);
-return x_64;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
-x_65 = lean_ctor_get(x_54, 1);
-lean_inc(x_65);
-lean_dec(x_54);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_3);
-x_66 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_65);
-if (lean_obj_tag(x_66) == 0)
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_67 = lean_ctor_get(x_66, 0);
-lean_inc(x_67);
-x_68 = lean_ctor_get(x_66, 1);
-lean_inc(x_68);
-lean_dec(x_66);
-x_69 = l_Lean_Meta_isExprDefEqAux(x_52, x_67, x_3, x_4, x_5, x_6, x_68);
-if (lean_obj_tag(x_69) == 0)
-{
-uint8_t x_70; 
-x_70 = !lean_is_exclusive(x_69);
-if (x_70 == 0)
-{
-lean_object* x_71; uint8_t x_72; uint8_t x_73; lean_object* x_74; 
-x_71 = lean_ctor_get(x_69, 0);
-x_72 = lean_unbox(x_71);
-lean_dec(x_71);
-x_73 = l_Bool_toLBool(x_72);
-x_74 = lean_box(x_73);
-lean_ctor_set(x_69, 0, x_74);
-return x_69;
-}
-else
-{
-lean_object* x_75; lean_object* x_76; uint8_t x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; 
-x_75 = lean_ctor_get(x_69, 0);
-x_76 = lean_ctor_get(x_69, 1);
-lean_inc(x_76);
-lean_inc(x_75);
-lean_dec(x_69);
-x_77 = lean_unbox(x_75);
-lean_dec(x_75);
-x_78 = l_Bool_toLBool(x_77);
-x_79 = lean_box(x_78);
-x_80 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_80, 1, x_76);
-return x_80;
-}
-}
-else
-{
-uint8_t x_81; 
-x_81 = !lean_is_exclusive(x_69);
-if (x_81 == 0)
-{
-return x_69;
-}
-else
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_82 = lean_ctor_get(x_69, 0);
-x_83 = lean_ctor_get(x_69, 1);
-lean_inc(x_83);
-lean_inc(x_82);
-lean_dec(x_69);
-x_84 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_84, 0, x_82);
-lean_ctor_set(x_84, 1, x_83);
-return x_84;
-}
-}
-}
-else
-{
-uint8_t x_85; 
-lean_dec(x_52);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_85 = !lean_is_exclusive(x_66);
-if (x_85 == 0)
+x_69 = !lean_is_exclusive(x_66);
+if (x_69 == 0)
 {
+lean_object* x_70; uint8_t x_71; lean_object* x_72; 
+x_70 = lean_ctor_get(x_66, 0);
+lean_dec(x_70);
+x_71 = 2;
+x_72 = lean_box(x_71);
+lean_ctor_set(x_66, 0, x_72);
 return x_66;
 }
 else
 {
-lean_object* x_86; lean_object* x_87; lean_object* x_88; 
-x_86 = lean_ctor_get(x_66, 0);
-x_87 = lean_ctor_get(x_66, 1);
-lean_inc(x_87);
-lean_inc(x_86);
+lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
+x_73 = lean_ctor_get(x_66, 1);
+lean_inc(x_73);
 lean_dec(x_66);
-x_88 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_88, 0, x_86);
-lean_ctor_set(x_88, 1, x_87);
-return x_88;
-}
-}
+x_74 = 2;
+x_75 = lean_box(x_74);
+x_76 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_76, 0, x_75);
+lean_ctor_set(x_76, 1, x_73);
+return x_76;
 }
 }
 else
 {
-uint8_t x_89; 
-lean_dec(x_52);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_89 = !lean_is_exclusive(x_54);
-if (x_89 == 0)
+lean_object* x_77; lean_object* x_78; 
+x_77 = lean_ctor_get(x_66, 1);
+lean_inc(x_77);
+lean_dec(x_66);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+x_78 = l_Lean_Meta_inferType(x_2, x_3, x_4, x_5, x_6, x_77);
+if (lean_obj_tag(x_78) == 0)
 {
-return x_54;
+lean_object* x_79; lean_object* x_80; lean_object* x_81; 
+x_79 = lean_ctor_get(x_78, 0);
+lean_inc(x_79);
+x_80 = lean_ctor_get(x_78, 1);
+lean_inc(x_80);
+lean_dec(x_78);
+x_81 = l_Lean_Meta_isExprDefEqAux(x_64, x_79, x_3, x_4, x_5, x_6, x_80);
+if (lean_obj_tag(x_81) == 0)
+{
+uint8_t x_82; 
+x_82 = !lean_is_exclusive(x_81);
+if (x_82 == 0)
+{
+lean_object* x_83; uint8_t x_84; uint8_t x_85; lean_object* x_86; 
+x_83 = lean_ctor_get(x_81, 0);
+x_84 = lean_unbox(x_83);
+lean_dec(x_83);
+x_85 = l_Bool_toLBool(x_84);
+x_86 = lean_box(x_85);
+lean_ctor_set(x_81, 0, x_86);
+return x_81;
 }
 else
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-x_90 = lean_ctor_get(x_54, 0);
-x_91 = lean_ctor_get(x_54, 1);
-lean_inc(x_91);
-lean_inc(x_90);
-lean_dec(x_54);
-x_92 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_92, 0, x_90);
-lean_ctor_set(x_92, 1, x_91);
+lean_object* x_87; lean_object* x_88; uint8_t x_89; uint8_t x_90; lean_object* x_91; lean_object* x_92; 
+x_87 = lean_ctor_get(x_81, 0);
+x_88 = lean_ctor_get(x_81, 1);
+lean_inc(x_88);
+lean_inc(x_87);
+lean_dec(x_81);
+x_89 = lean_unbox(x_87);
+lean_dec(x_87);
+x_90 = l_Bool_toLBool(x_89);
+x_91 = lean_box(x_90);
+x_92 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_92, 0, x_91);
+lean_ctor_set(x_92, 1, x_88);
 return x_92;
 }
 }
-}
 else
 {
 uint8_t x_93; 
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_93 = !lean_is_exclusive(x_51);
+x_93 = !lean_is_exclusive(x_81);
 if (x_93 == 0)
 {
-return x_51;
+return x_81;
 }
 else
 {
 lean_object* x_94; lean_object* x_95; lean_object* x_96; 
-x_94 = lean_ctor_get(x_51, 0);
-x_95 = lean_ctor_get(x_51, 1);
+x_94 = lean_ctor_get(x_81, 0);
+x_95 = lean_ctor_get(x_81, 1);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_51);
+lean_dec(x_81);
 x_96 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_96, 0, x_94);
 lean_ctor_set(x_96, 1, x_95);
@@ -48030,34 +48003,121 @@ return x_96;
 }
 }
 }
+else
+{
+uint8_t x_97; 
+lean_dec(x_64);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_97 = !lean_is_exclusive(x_78);
+if (x_97 == 0)
+{
+return x_78;
+}
+else
+{
+lean_object* x_98; lean_object* x_99; lean_object* x_100; 
+x_98 = lean_ctor_get(x_78, 0);
+x_99 = lean_ctor_get(x_78, 1);
+lean_inc(x_99);
+lean_inc(x_98);
+lean_dec(x_78);
+x_100 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_100, 0, x_98);
+lean_ctor_set(x_100, 1, x_99);
+return x_100;
+}
+}
 }
 }
 else
 {
-uint8_t x_97; 
+uint8_t x_101; 
+lean_dec(x_64);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_101 = !lean_is_exclusive(x_66);
+if (x_101 == 0)
+{
+return x_66;
+}
+else
+{
+lean_object* x_102; lean_object* x_103; lean_object* x_104; 
+x_102 = lean_ctor_get(x_66, 0);
+x_103 = lean_ctor_get(x_66, 1);
+lean_inc(x_103);
+lean_inc(x_102);
+lean_dec(x_66);
+x_104 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_104, 0, x_102);
+lean_ctor_set(x_104, 1, x_103);
+return x_104;
+}
+}
+}
+else
+{
+uint8_t x_105; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_105 = !lean_is_exclusive(x_63);
+if (x_105 == 0)
+{
+return x_63;
+}
+else
+{
+lean_object* x_106; lean_object* x_107; lean_object* x_108; 
+x_106 = lean_ctor_get(x_63, 0);
+x_107 = lean_ctor_get(x_63, 1);
+lean_inc(x_107);
+lean_inc(x_106);
+lean_dec(x_63);
+x_108 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_108, 0, x_106);
+lean_ctor_set(x_108, 1, x_107);
+return x_108;
+}
+}
+}
+}
+}
+else
+{
+uint8_t x_109; 
 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_97 = !lean_is_exclusive(x_8);
-if (x_97 == 0)
+x_109 = !lean_is_exclusive(x_20);
+if (x_109 == 0)
 {
-return x_8;
+return x_20;
 }
 else
 {
-lean_object* x_98; lean_object* x_99; lean_object* x_100; 
-x_98 = lean_ctor_get(x_8, 0);
-x_99 = lean_ctor_get(x_8, 1);
-lean_inc(x_99);
-lean_inc(x_98);
-lean_dec(x_8);
-x_100 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_100, 0, x_98);
-lean_ctor_set(x_100, 1, x_99);
-return x_100;
+lean_object* x_110; lean_object* x_111; lean_object* x_112; 
+x_110 = lean_ctor_get(x_20, 0);
+x_111 = lean_ctor_get(x_20, 1);
+lean_inc(x_111);
+lean_inc(x_110);
+lean_dec(x_20);
+x_112 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_112, 0, x_110);
+lean_ctor_set(x_112, 1, x_111);
+return x_112;
+}
 }
 }
 }
@@ -64765,7 +64825,7 @@ lean_dec(x_3);
 return x_8;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -64773,12 +64833,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Meta_isExprDefEqAuxImpl), 7, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; uint8_t x_5; 
 x_2 = l_Lean_Meta_isExprDefEqAuxRef;
-x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456____closed__1;
+x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474____closed__1;
 x_4 = lean_st_ref_set(x_2, x_3, x_1);
 x_5 = !lean_is_exclusive(x_4);
 if (x_5 == 0)
@@ -64800,7 +64860,7 @@ return x_8;
 }
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9465_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9483_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -65181,12 +65241,12 @@ l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_unstuckMVar___closed__13 = _init_l_
 lean_mark_persistent(l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_unstuckMVar___closed__13);
 l_Lean_Meta_isExprDefEqAuxImpl___closed__1 = _init_l_Lean_Meta_isExprDefEqAuxImpl___closed__1();
 lean_mark_persistent(l_Lean_Meta_isExprDefEqAuxImpl___closed__1);
-l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456____closed__1);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9456_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474____closed__1);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9474_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9465_(lean_io_mk_world());
+res = l_Lean_Meta_initFn____x40_Lean_Meta_ExprDefEq___hyg_9483_(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));
diff --git a/stage0/stdlib/Lean/Meta/FunInfo.c b/stage0/stdlib/Lean/Meta/FunInfo.c
index e09359ad5b..6d50d7266d 100644
--- a/stage0/stdlib/Lean/Meta/FunInfo.c
+++ b/stage0/stdlib/Lean/Meta/FunInfo.c
@@ -63,7 +63,7 @@ lean_object* l___private_Lean_Meta_FunInfo_0__Lean_Meta_collectDeps_visit_match_
 extern lean_object* l_Lean_instInhabitedExpr;
 size_t l_USize_mul(size_t, size_t);
 lean_object* l_Array_anyMUnsafe_any___at___private_Lean_Meta_FunInfo_0__Lean_Meta_collectDeps_visit___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(lean_object*, lean_object*);
+uint8_t l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l___private_Lean_Meta_FunInfo_0__Lean_Meta_whenHasVar___rarg(lean_object*, lean_object*, lean_object*);
@@ -160,7 +160,7 @@ else
 {
 lean_object* x_9; uint8_t x_10; 
 x_9 = lean_array_fget(x_1, x_4);
-x_10 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(x_5, x_9);
+x_10 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(x_5, x_9);
 lean_dec(x_9);
 if (x_10 == 0)
 {
@@ -210,7 +210,7 @@ lean_inc(x_11);
 x_12 = lean_ctor_get(x_10, 1);
 lean_inc(x_12);
 lean_dec(x_10);
-x_13 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(x_3, x_11);
+x_13 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(x_3, x_11);
 lean_dec(x_11);
 if (x_13 == 0)
 {
@@ -409,7 +409,7 @@ else
 {
 lean_object* x_17; uint8_t x_18; 
 x_17 = lean_array_fget(x_5, x_2);
-x_18 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(x_3, x_17);
+x_18 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(x_3, x_17);
 lean_dec(x_17);
 if (x_18 == 0)
 {
@@ -498,7 +498,7 @@ if (x_18 == 0)
 lean_object* x_19; lean_object* x_20; uint8_t x_21; 
 x_19 = lean_ctor_get(x_15, 0);
 x_20 = lean_ctor_get(x_15, 1);
-x_21 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(x_4, x_19);
+x_21 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(x_4, x_19);
 if (x_21 == 0)
 {
 lean_object* x_22; lean_object* x_23; lean_object* x_24; 
@@ -532,7 +532,7 @@ x_27 = lean_ctor_get(x_15, 1);
 lean_inc(x_27);
 lean_inc(x_26);
 lean_dec(x_15);
-x_28 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(x_4, x_26);
+x_28 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(x_4, x_26);
 if (x_28 == 0)
 {
 lean_object* x_29; lean_object* x_30; lean_object* x_31; 
@@ -653,7 +653,7 @@ if (lean_is_exclusive(x_57)) {
  lean_dec_ref(x_57);
  x_62 = lean_box(0);
 }
-x_63 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_236_(x_4, x_60);
+x_63 = l___private_Lean_Meta_Basic_0__Lean_Meta_beqInfoCacheKey____x40_Lean_Meta_Basic___hyg_245_(x_4, x_60);
 if (x_63 == 0)
 {
 lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
@@ -2839,7 +2839,7 @@ return x_80;
 }
 else
 {
-uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; uint8_t x_88; uint8_t x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; uint8_t x_87; uint8_t x_88; uint8_t x_89; uint8_t x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; 
 x_81 = lean_ctor_get_uint8(x_23, 0);
 x_82 = lean_ctor_get_uint8(x_23, 1);
 x_83 = lean_ctor_get_uint8(x_23, 2);
@@ -2848,361 +2848,365 @@ x_85 = lean_ctor_get_uint8(x_23, 4);
 x_86 = lean_ctor_get_uint8(x_23, 6);
 x_87 = lean_ctor_get_uint8(x_23, 7);
 x_88 = lean_ctor_get_uint8(x_23, 8);
+x_89 = lean_ctor_get_uint8(x_23, 9);
 lean_dec(x_23);
-x_89 = 1;
-x_90 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_90, 0, x_81);
-lean_ctor_set_uint8(x_90, 1, x_82);
-lean_ctor_set_uint8(x_90, 2, x_83);
-lean_ctor_set_uint8(x_90, 3, x_84);
-lean_ctor_set_uint8(x_90, 4, x_85);
-lean_ctor_set_uint8(x_90, 5, x_89);
-lean_ctor_set_uint8(x_90, 6, x_86);
-lean_ctor_set_uint8(x_90, 7, x_87);
-lean_ctor_set_uint8(x_90, 8, x_88);
-lean_ctor_set(x_3, 0, x_90);
-x_91 = l___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___closed__1;
+x_90 = 1;
+x_91 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_91, 0, x_81);
+lean_ctor_set_uint8(x_91, 1, x_82);
+lean_ctor_set_uint8(x_91, 2, x_83);
+lean_ctor_set_uint8(x_91, 3, x_84);
+lean_ctor_set_uint8(x_91, 4, x_85);
+lean_ctor_set_uint8(x_91, 5, x_90);
+lean_ctor_set_uint8(x_91, 6, x_86);
+lean_ctor_set_uint8(x_91, 7, x_87);
+lean_ctor_set_uint8(x_91, 8, x_88);
+lean_ctor_set_uint8(x_91, 9, x_89);
+lean_ctor_set(x_3, 0, x_91);
+x_92 = l___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___closed__1;
 lean_inc(x_6);
 lean_inc(x_4);
-x_92 = l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__2___rarg(x_24, x_2, x_91, x_3, x_4, x_5, x_6, x_25);
-if (lean_obj_tag(x_92) == 0)
+x_93 = l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__2___rarg(x_24, x_2, x_92, x_3, x_4, x_5, x_6, x_25);
+if (lean_obj_tag(x_93) == 0)
 {
-lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
-x_93 = lean_ctor_get(x_92, 0);
-lean_inc(x_93);
-x_94 = lean_ctor_get(x_92, 1);
+lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
+x_94 = lean_ctor_get(x_93, 0);
 lean_inc(x_94);
-lean_dec(x_92);
-x_95 = lean_st_ref_get(x_6, x_94);
+x_95 = lean_ctor_get(x_93, 1);
+lean_inc(x_95);
+lean_dec(x_93);
+x_96 = lean_st_ref_get(x_6, x_95);
 lean_dec(x_6);
-x_96 = lean_ctor_get(x_95, 1);
-lean_inc(x_96);
-lean_dec(x_95);
-x_97 = lean_st_ref_take(x_4, x_96);
-x_98 = lean_ctor_get(x_97, 0);
-lean_inc(x_98);
-x_99 = lean_ctor_get(x_98, 1);
+x_97 = lean_ctor_get(x_96, 1);
+lean_inc(x_97);
+lean_dec(x_96);
+x_98 = lean_st_ref_take(x_4, x_97);
+x_99 = lean_ctor_get(x_98, 0);
 lean_inc(x_99);
-x_100 = lean_ctor_get(x_97, 1);
+x_100 = lean_ctor_get(x_99, 1);
 lean_inc(x_100);
-lean_dec(x_97);
-x_101 = lean_ctor_get(x_98, 0);
+x_101 = lean_ctor_get(x_98, 1);
 lean_inc(x_101);
-x_102 = lean_ctor_get(x_98, 2);
+lean_dec(x_98);
+x_102 = lean_ctor_get(x_99, 0);
 lean_inc(x_102);
-x_103 = lean_ctor_get(x_98, 3);
+x_103 = lean_ctor_get(x_99, 2);
 lean_inc(x_103);
-if (lean_is_exclusive(x_98)) {
- lean_ctor_release(x_98, 0);
- lean_ctor_release(x_98, 1);
- lean_ctor_release(x_98, 2);
- lean_ctor_release(x_98, 3);
- x_104 = x_98;
-} else {
- lean_dec_ref(x_98);
- x_104 = lean_box(0);
-}
-x_105 = lean_ctor_get(x_99, 0);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_99, 2);
-lean_inc(x_106);
-x_107 = lean_ctor_get(x_99, 3);
-lean_inc(x_107);
-x_108 = lean_ctor_get(x_99, 4);
-lean_inc(x_108);
-x_109 = lean_ctor_get(x_99, 1);
-lean_inc(x_109);
+x_104 = lean_ctor_get(x_99, 3);
+lean_inc(x_104);
 if (lean_is_exclusive(x_99)) {
  lean_ctor_release(x_99, 0);
  lean_ctor_release(x_99, 1);
  lean_ctor_release(x_99, 2);
  lean_ctor_release(x_99, 3);
- lean_ctor_release(x_99, 4);
- x_110 = x_99;
+ x_105 = x_99;
 } else {
  lean_dec_ref(x_99);
- x_110 = lean_box(0);
+ x_105 = lean_box(0);
 }
-lean_inc(x_93);
-x_111 = l_Std_PersistentHashMap_insert___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__4(x_109, x_19, x_93);
-if (lean_is_scalar(x_110)) {
- x_112 = lean_alloc_ctor(0, 5, 0);
+x_106 = lean_ctor_get(x_100, 0);
+lean_inc(x_106);
+x_107 = lean_ctor_get(x_100, 2);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_100, 3);
+lean_inc(x_108);
+x_109 = lean_ctor_get(x_100, 4);
+lean_inc(x_109);
+x_110 = lean_ctor_get(x_100, 1);
+lean_inc(x_110);
+if (lean_is_exclusive(x_100)) {
+ lean_ctor_release(x_100, 0);
+ lean_ctor_release(x_100, 1);
+ lean_ctor_release(x_100, 2);
+ lean_ctor_release(x_100, 3);
+ lean_ctor_release(x_100, 4);
+ x_111 = x_100;
 } else {
- x_112 = x_110;
+ lean_dec_ref(x_100);
+ x_111 = lean_box(0);
 }
-lean_ctor_set(x_112, 0, x_105);
-lean_ctor_set(x_112, 1, x_111);
-lean_ctor_set(x_112, 2, x_106);
-lean_ctor_set(x_112, 3, x_107);
-lean_ctor_set(x_112, 4, x_108);
-if (lean_is_scalar(x_104)) {
- x_113 = lean_alloc_ctor(0, 4, 0);
+lean_inc(x_94);
+x_112 = l_Std_PersistentHashMap_insert___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__4(x_110, x_19, x_94);
+if (lean_is_scalar(x_111)) {
+ x_113 = lean_alloc_ctor(0, 5, 0);
 } else {
- x_113 = x_104;
+ x_113 = x_111;
 }
-lean_ctor_set(x_113, 0, x_101);
+lean_ctor_set(x_113, 0, x_106);
 lean_ctor_set(x_113, 1, x_112);
-lean_ctor_set(x_113, 2, x_102);
-lean_ctor_set(x_113, 3, x_103);
-x_114 = lean_st_ref_set(x_4, x_113, x_100);
+lean_ctor_set(x_113, 2, x_107);
+lean_ctor_set(x_113, 3, x_108);
+lean_ctor_set(x_113, 4, x_109);
+if (lean_is_scalar(x_105)) {
+ x_114 = lean_alloc_ctor(0, 4, 0);
+} else {
+ x_114 = x_105;
+}
+lean_ctor_set(x_114, 0, x_102);
+lean_ctor_set(x_114, 1, x_113);
+lean_ctor_set(x_114, 2, x_103);
+lean_ctor_set(x_114, 3, x_104);
+x_115 = lean_st_ref_set(x_4, x_114, x_101);
 lean_dec(x_4);
-x_115 = lean_ctor_get(x_114, 1);
-lean_inc(x_115);
-if (lean_is_exclusive(x_114)) {
- lean_ctor_release(x_114, 0);
- lean_ctor_release(x_114, 1);
- x_116 = x_114;
+x_116 = lean_ctor_get(x_115, 1);
+lean_inc(x_116);
+if (lean_is_exclusive(x_115)) {
+ lean_ctor_release(x_115, 0);
+ lean_ctor_release(x_115, 1);
+ x_117 = x_115;
 } else {
- lean_dec_ref(x_114);
- x_116 = lean_box(0);
+ lean_dec_ref(x_115);
+ x_117 = lean_box(0);
 }
-if (lean_is_scalar(x_116)) {
- x_117 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_117)) {
+ x_118 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_117 = x_116;
+ x_118 = x_117;
 }
-lean_ctor_set(x_117, 0, x_93);
-lean_ctor_set(x_117, 1, x_115);
-return x_117;
+lean_ctor_set(x_118, 0, x_94);
+lean_ctor_set(x_118, 1, x_116);
+return x_118;
 }
 else
 {
-lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; 
 lean_dec(x_19);
 lean_dec(x_6);
 lean_dec(x_4);
-x_118 = lean_ctor_get(x_92, 0);
-lean_inc(x_118);
-x_119 = lean_ctor_get(x_92, 1);
+x_119 = lean_ctor_get(x_93, 0);
 lean_inc(x_119);
-if (lean_is_exclusive(x_92)) {
- lean_ctor_release(x_92, 0);
- lean_ctor_release(x_92, 1);
- x_120 = x_92;
+x_120 = lean_ctor_get(x_93, 1);
+lean_inc(x_120);
+if (lean_is_exclusive(x_93)) {
+ lean_ctor_release(x_93, 0);
+ lean_ctor_release(x_93, 1);
+ x_121 = x_93;
 } else {
- lean_dec_ref(x_92);
- x_120 = lean_box(0);
+ lean_dec_ref(x_93);
+ x_121 = lean_box(0);
 }
-if (lean_is_scalar(x_120)) {
- x_121 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_121)) {
+ x_122 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_121 = x_120;
+ x_122 = x_121;
 }
-lean_ctor_set(x_121, 0, x_118);
-lean_ctor_set(x_121, 1, x_119);
-return x_121;
+lean_ctor_set(x_122, 0, x_119);
+lean_ctor_set(x_122, 1, x_120);
+return x_122;
 }
 }
 }
 else
 {
-lean_object* x_122; lean_object* x_123; lean_object* x_124; uint8_t x_125; uint8_t x_126; uint8_t x_127; uint8_t x_128; uint8_t x_129; uint8_t x_130; uint8_t x_131; uint8_t x_132; lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; 
-x_122 = lean_ctor_get(x_3, 1);
-x_123 = lean_ctor_get(x_3, 2);
-x_124 = lean_ctor_get(x_3, 3);
+lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; uint8_t x_127; uint8_t x_128; uint8_t x_129; uint8_t x_130; uint8_t x_131; uint8_t x_132; uint8_t x_133; uint8_t x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
+x_123 = lean_ctor_get(x_3, 1);
+x_124 = lean_ctor_get(x_3, 2);
+x_125 = lean_ctor_get(x_3, 3);
+lean_inc(x_125);
 lean_inc(x_124);
 lean_inc(x_123);
-lean_inc(x_122);
 lean_dec(x_3);
-x_125 = lean_ctor_get_uint8(x_23, 0);
-x_126 = lean_ctor_get_uint8(x_23, 1);
-x_127 = lean_ctor_get_uint8(x_23, 2);
-x_128 = lean_ctor_get_uint8(x_23, 3);
-x_129 = lean_ctor_get_uint8(x_23, 4);
-x_130 = lean_ctor_get_uint8(x_23, 6);
-x_131 = lean_ctor_get_uint8(x_23, 7);
-x_132 = lean_ctor_get_uint8(x_23, 8);
+x_126 = lean_ctor_get_uint8(x_23, 0);
+x_127 = lean_ctor_get_uint8(x_23, 1);
+x_128 = lean_ctor_get_uint8(x_23, 2);
+x_129 = lean_ctor_get_uint8(x_23, 3);
+x_130 = lean_ctor_get_uint8(x_23, 4);
+x_131 = lean_ctor_get_uint8(x_23, 6);
+x_132 = lean_ctor_get_uint8(x_23, 7);
+x_133 = lean_ctor_get_uint8(x_23, 8);
+x_134 = lean_ctor_get_uint8(x_23, 9);
 if (lean_is_exclusive(x_23)) {
- x_133 = x_23;
+ x_135 = x_23;
 } else {
  lean_dec_ref(x_23);
- x_133 = lean_box(0);
+ x_135 = lean_box(0);
 }
-x_134 = 1;
-if (lean_is_scalar(x_133)) {
- x_135 = lean_alloc_ctor(0, 0, 9);
+x_136 = 1;
+if (lean_is_scalar(x_135)) {
+ x_137 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_135 = x_133;
+ x_137 = x_135;
 }
-lean_ctor_set_uint8(x_135, 0, x_125);
-lean_ctor_set_uint8(x_135, 1, x_126);
-lean_ctor_set_uint8(x_135, 2, x_127);
-lean_ctor_set_uint8(x_135, 3, x_128);
-lean_ctor_set_uint8(x_135, 4, x_129);
-lean_ctor_set_uint8(x_135, 5, x_134);
-lean_ctor_set_uint8(x_135, 6, x_130);
-lean_ctor_set_uint8(x_135, 7, x_131);
-lean_ctor_set_uint8(x_135, 8, x_132);
-x_136 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_136, 0, x_135);
-lean_ctor_set(x_136, 1, x_122);
-lean_ctor_set(x_136, 2, x_123);
-lean_ctor_set(x_136, 3, x_124);
-x_137 = l___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___closed__1;
+lean_ctor_set_uint8(x_137, 0, x_126);
+lean_ctor_set_uint8(x_137, 1, x_127);
+lean_ctor_set_uint8(x_137, 2, x_128);
+lean_ctor_set_uint8(x_137, 3, x_129);
+lean_ctor_set_uint8(x_137, 4, x_130);
+lean_ctor_set_uint8(x_137, 5, x_136);
+lean_ctor_set_uint8(x_137, 6, x_131);
+lean_ctor_set_uint8(x_137, 7, x_132);
+lean_ctor_set_uint8(x_137, 8, x_133);
+lean_ctor_set_uint8(x_137, 9, x_134);
+x_138 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_138, 0, x_137);
+lean_ctor_set(x_138, 1, x_123);
+lean_ctor_set(x_138, 2, x_124);
+lean_ctor_set(x_138, 3, x_125);
+x_139 = l___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___closed__1;
 lean_inc(x_6);
 lean_inc(x_4);
-x_138 = l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__2___rarg(x_24, x_2, x_137, x_136, x_4, x_5, x_6, x_25);
-if (lean_obj_tag(x_138) == 0)
+x_140 = l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__2___rarg(x_24, x_2, x_139, x_138, x_4, x_5, x_6, x_25);
+if (lean_obj_tag(x_140) == 0)
 {
-lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; 
-x_139 = lean_ctor_get(x_138, 0);
-lean_inc(x_139);
-x_140 = lean_ctor_get(x_138, 1);
-lean_inc(x_140);
-lean_dec(x_138);
-x_141 = lean_st_ref_get(x_6, x_140);
-lean_dec(x_6);
-x_142 = lean_ctor_get(x_141, 1);
+lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; 
+x_141 = lean_ctor_get(x_140, 0);
+lean_inc(x_141);
+x_142 = lean_ctor_get(x_140, 1);
 lean_inc(x_142);
-lean_dec(x_141);
-x_143 = lean_st_ref_take(x_4, x_142);
-x_144 = lean_ctor_get(x_143, 0);
+lean_dec(x_140);
+x_143 = lean_st_ref_get(x_6, x_142);
+lean_dec(x_6);
+x_144 = lean_ctor_get(x_143, 1);
 lean_inc(x_144);
-x_145 = lean_ctor_get(x_144, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_143, 1);
-lean_inc(x_146);
 lean_dec(x_143);
-x_147 = lean_ctor_get(x_144, 0);
+x_145 = lean_st_ref_take(x_4, x_144);
+x_146 = lean_ctor_get(x_145, 0);
+lean_inc(x_146);
+x_147 = lean_ctor_get(x_146, 1);
 lean_inc(x_147);
-x_148 = lean_ctor_get(x_144, 2);
+x_148 = lean_ctor_get(x_145, 1);
 lean_inc(x_148);
-x_149 = lean_ctor_get(x_144, 3);
+lean_dec(x_145);
+x_149 = lean_ctor_get(x_146, 0);
 lean_inc(x_149);
-if (lean_is_exclusive(x_144)) {
- lean_ctor_release(x_144, 0);
- lean_ctor_release(x_144, 1);
- lean_ctor_release(x_144, 2);
- lean_ctor_release(x_144, 3);
- x_150 = x_144;
-} else {
- lean_dec_ref(x_144);
- x_150 = lean_box(0);
-}
-x_151 = lean_ctor_get(x_145, 0);
+x_150 = lean_ctor_get(x_146, 2);
+lean_inc(x_150);
+x_151 = lean_ctor_get(x_146, 3);
 lean_inc(x_151);
-x_152 = lean_ctor_get(x_145, 2);
-lean_inc(x_152);
-x_153 = lean_ctor_get(x_145, 3);
+if (lean_is_exclusive(x_146)) {
+ lean_ctor_release(x_146, 0);
+ lean_ctor_release(x_146, 1);
+ lean_ctor_release(x_146, 2);
+ lean_ctor_release(x_146, 3);
+ x_152 = x_146;
+} else {
+ lean_dec_ref(x_146);
+ x_152 = lean_box(0);
+}
+x_153 = lean_ctor_get(x_147, 0);
 lean_inc(x_153);
-x_154 = lean_ctor_get(x_145, 4);
+x_154 = lean_ctor_get(x_147, 2);
 lean_inc(x_154);
-x_155 = lean_ctor_get(x_145, 1);
+x_155 = lean_ctor_get(x_147, 3);
 lean_inc(x_155);
-if (lean_is_exclusive(x_145)) {
- lean_ctor_release(x_145, 0);
- lean_ctor_release(x_145, 1);
- lean_ctor_release(x_145, 2);
- lean_ctor_release(x_145, 3);
- lean_ctor_release(x_145, 4);
- x_156 = x_145;
+x_156 = lean_ctor_get(x_147, 4);
+lean_inc(x_156);
+x_157 = lean_ctor_get(x_147, 1);
+lean_inc(x_157);
+if (lean_is_exclusive(x_147)) {
+ lean_ctor_release(x_147, 0);
+ lean_ctor_release(x_147, 1);
+ lean_ctor_release(x_147, 2);
+ lean_ctor_release(x_147, 3);
+ lean_ctor_release(x_147, 4);
+ x_158 = x_147;
 } else {
- lean_dec_ref(x_145);
- x_156 = lean_box(0);
+ lean_dec_ref(x_147);
+ x_158 = lean_box(0);
 }
-lean_inc(x_139);
-x_157 = l_Std_PersistentHashMap_insert___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__4(x_155, x_19, x_139);
-if (lean_is_scalar(x_156)) {
- x_158 = lean_alloc_ctor(0, 5, 0);
+lean_inc(x_141);
+x_159 = l_Std_PersistentHashMap_insert___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__4(x_157, x_19, x_141);
+if (lean_is_scalar(x_158)) {
+ x_160 = lean_alloc_ctor(0, 5, 0);
 } else {
- x_158 = x_156;
+ x_160 = x_158;
 }
-lean_ctor_set(x_158, 0, x_151);
-lean_ctor_set(x_158, 1, x_157);
-lean_ctor_set(x_158, 2, x_152);
-lean_ctor_set(x_158, 3, x_153);
-lean_ctor_set(x_158, 4, x_154);
-if (lean_is_scalar(x_150)) {
- x_159 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_160, 0, x_153);
+lean_ctor_set(x_160, 1, x_159);
+lean_ctor_set(x_160, 2, x_154);
+lean_ctor_set(x_160, 3, x_155);
+lean_ctor_set(x_160, 4, x_156);
+if (lean_is_scalar(x_152)) {
+ x_161 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_159 = x_150;
+ x_161 = x_152;
 }
-lean_ctor_set(x_159, 0, x_147);
-lean_ctor_set(x_159, 1, x_158);
-lean_ctor_set(x_159, 2, x_148);
-lean_ctor_set(x_159, 3, x_149);
-x_160 = lean_st_ref_set(x_4, x_159, x_146);
+lean_ctor_set(x_161, 0, x_149);
+lean_ctor_set(x_161, 1, x_160);
+lean_ctor_set(x_161, 2, x_150);
+lean_ctor_set(x_161, 3, x_151);
+x_162 = lean_st_ref_set(x_4, x_161, x_148);
 lean_dec(x_4);
-x_161 = lean_ctor_get(x_160, 1);
-lean_inc(x_161);
-if (lean_is_exclusive(x_160)) {
- lean_ctor_release(x_160, 0);
- lean_ctor_release(x_160, 1);
- x_162 = x_160;
+x_163 = lean_ctor_get(x_162, 1);
+lean_inc(x_163);
+if (lean_is_exclusive(x_162)) {
+ lean_ctor_release(x_162, 0);
+ lean_ctor_release(x_162, 1);
+ x_164 = x_162;
 } else {
- lean_dec_ref(x_160);
- x_162 = lean_box(0);
+ lean_dec_ref(x_162);
+ x_164 = lean_box(0);
 }
-if (lean_is_scalar(x_162)) {
- x_163 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_164)) {
+ x_165 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_163 = x_162;
+ x_165 = x_164;
 }
-lean_ctor_set(x_163, 0, x_139);
-lean_ctor_set(x_163, 1, x_161);
-return x_163;
+lean_ctor_set(x_165, 0, x_141);
+lean_ctor_set(x_165, 1, x_163);
+return x_165;
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; 
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; 
 lean_dec(x_19);
 lean_dec(x_6);
 lean_dec(x_4);
-x_164 = lean_ctor_get(x_138, 0);
-lean_inc(x_164);
-x_165 = lean_ctor_get(x_138, 1);
-lean_inc(x_165);
-if (lean_is_exclusive(x_138)) {
- lean_ctor_release(x_138, 0);
- lean_ctor_release(x_138, 1);
- x_166 = x_138;
+x_166 = lean_ctor_get(x_140, 0);
+lean_inc(x_166);
+x_167 = lean_ctor_get(x_140, 1);
+lean_inc(x_167);
+if (lean_is_exclusive(x_140)) {
+ lean_ctor_release(x_140, 0);
+ lean_ctor_release(x_140, 1);
+ x_168 = x_140;
 } else {
- lean_dec_ref(x_138);
- x_166 = lean_box(0);
+ lean_dec_ref(x_140);
+ x_168 = lean_box(0);
 }
-if (lean_is_scalar(x_166)) {
- x_167 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_168)) {
+ x_169 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_167 = x_166;
+ x_169 = x_168;
 }
-lean_ctor_set(x_167, 0, x_164);
-lean_ctor_set(x_167, 1, x_165);
-return x_167;
+lean_ctor_set(x_169, 0, x_166);
+lean_ctor_set(x_169, 1, x_167);
+return x_169;
 }
 }
 }
 else
 {
-uint8_t x_168; 
+uint8_t x_170; 
 lean_dec(x_19);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_168 = !lean_is_exclusive(x_22);
-if (x_168 == 0)
+x_170 = !lean_is_exclusive(x_22);
+if (x_170 == 0)
 {
 return x_22;
 }
 else
 {
-lean_object* x_169; lean_object* x_170; lean_object* x_171; 
-x_169 = lean_ctor_get(x_22, 0);
-x_170 = lean_ctor_get(x_22, 1);
-lean_inc(x_170);
-lean_inc(x_169);
+lean_object* x_171; lean_object* x_172; lean_object* x_173; 
+x_171 = lean_ctor_get(x_22, 0);
+x_172 = lean_ctor_get(x_22, 1);
+lean_inc(x_172);
+lean_inc(x_171);
 lean_dec(x_22);
-x_171 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_171, 0, x_169);
-lean_ctor_set(x_171, 1, x_170);
-return x_171;
+x_173 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_173, 0, x_171);
+lean_ctor_set(x_173, 1, x_172);
+return x_173;
 }
 }
 }
 else
 {
-lean_object* x_172; 
+lean_object* x_174; 
 lean_dec(x_19);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3210,288 +3214,290 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_172 = lean_ctor_get(x_21, 0);
-lean_inc(x_172);
+x_174 = lean_ctor_get(x_21, 0);
+lean_inc(x_174);
 lean_dec(x_21);
-lean_ctor_set(x_13, 0, x_172);
+lean_ctor_set(x_13, 0, x_174);
 return x_13;
 }
 }
 else
 {
-lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; lean_object* x_179; 
-x_173 = lean_ctor_get(x_13, 0);
-x_174 = lean_ctor_get(x_13, 1);
-lean_inc(x_174);
-lean_inc(x_173);
-lean_dec(x_13);
-x_175 = lean_ctor_get(x_11, 1);
-lean_inc(x_175);
-lean_dec(x_11);
-x_176 = lean_ctor_get(x_175, 1);
+lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; uint8_t x_180; lean_object* x_181; 
+x_175 = lean_ctor_get(x_13, 0);
+x_176 = lean_ctor_get(x_13, 1);
 lean_inc(x_176);
-lean_dec(x_175);
+lean_inc(x_175);
+lean_dec(x_13);
+x_177 = lean_ctor_get(x_11, 1);
+lean_inc(x_177);
+lean_dec(x_11);
+x_178 = lean_ctor_get(x_177, 1);
+lean_inc(x_178);
+lean_dec(x_177);
 lean_inc(x_2);
 lean_inc(x_1);
-x_177 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_177, 0, x_1);
-lean_ctor_set(x_177, 1, x_2);
-x_178 = lean_unbox(x_173);
-lean_dec(x_173);
-lean_ctor_set_uint8(x_177, sizeof(void*)*2, x_178);
-x_179 = l_Std_PersistentHashMap_find_x3f___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__1(x_176, x_177);
-if (lean_obj_tag(x_179) == 0)
+x_179 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_179, 0, x_1);
+lean_ctor_set(x_179, 1, x_2);
+x_180 = lean_unbox(x_175);
+lean_dec(x_175);
+lean_ctor_set_uint8(x_179, sizeof(void*)*2, x_180);
+x_181 = l_Std_PersistentHashMap_find_x3f___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__1(x_178, x_179);
+if (lean_obj_tag(x_181) == 0)
 {
-lean_object* x_180; 
+lean_object* x_182; 
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_180 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_174);
-if (lean_obj_tag(x_180) == 0)
+x_182 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_176);
+if (lean_obj_tag(x_182) == 0)
 {
-lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; uint8_t x_188; uint8_t x_189; uint8_t x_190; uint8_t x_191; uint8_t x_192; uint8_t x_193; uint8_t x_194; uint8_t x_195; lean_object* x_196; uint8_t x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; 
-x_181 = lean_ctor_get(x_3, 0);
-lean_inc(x_181);
-x_182 = lean_ctor_get(x_180, 0);
-lean_inc(x_182);
-x_183 = lean_ctor_get(x_180, 1);
+lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; uint8_t x_192; uint8_t x_193; uint8_t x_194; uint8_t x_195; uint8_t x_196; uint8_t x_197; uint8_t x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; 
+x_183 = lean_ctor_get(x_3, 0);
 lean_inc(x_183);
-lean_dec(x_180);
-x_184 = lean_ctor_get(x_3, 1);
+x_184 = lean_ctor_get(x_182, 0);
 lean_inc(x_184);
-x_185 = lean_ctor_get(x_3, 2);
+x_185 = lean_ctor_get(x_182, 1);
 lean_inc(x_185);
-x_186 = lean_ctor_get(x_3, 3);
+lean_dec(x_182);
+x_186 = lean_ctor_get(x_3, 1);
 lean_inc(x_186);
+x_187 = lean_ctor_get(x_3, 2);
+lean_inc(x_187);
+x_188 = lean_ctor_get(x_3, 3);
+lean_inc(x_188);
 if (lean_is_exclusive(x_3)) {
  lean_ctor_release(x_3, 0);
  lean_ctor_release(x_3, 1);
  lean_ctor_release(x_3, 2);
  lean_ctor_release(x_3, 3);
- x_187 = x_3;
+ x_189 = x_3;
 } else {
  lean_dec_ref(x_3);
- x_187 = lean_box(0);
+ x_189 = lean_box(0);
 }
-x_188 = lean_ctor_get_uint8(x_181, 0);
-x_189 = lean_ctor_get_uint8(x_181, 1);
-x_190 = lean_ctor_get_uint8(x_181, 2);
-x_191 = lean_ctor_get_uint8(x_181, 3);
-x_192 = lean_ctor_get_uint8(x_181, 4);
-x_193 = lean_ctor_get_uint8(x_181, 6);
-x_194 = lean_ctor_get_uint8(x_181, 7);
-x_195 = lean_ctor_get_uint8(x_181, 8);
-if (lean_is_exclusive(x_181)) {
- x_196 = x_181;
+x_190 = lean_ctor_get_uint8(x_183, 0);
+x_191 = lean_ctor_get_uint8(x_183, 1);
+x_192 = lean_ctor_get_uint8(x_183, 2);
+x_193 = lean_ctor_get_uint8(x_183, 3);
+x_194 = lean_ctor_get_uint8(x_183, 4);
+x_195 = lean_ctor_get_uint8(x_183, 6);
+x_196 = lean_ctor_get_uint8(x_183, 7);
+x_197 = lean_ctor_get_uint8(x_183, 8);
+x_198 = lean_ctor_get_uint8(x_183, 9);
+if (lean_is_exclusive(x_183)) {
+ x_199 = x_183;
 } else {
- lean_dec_ref(x_181);
- x_196 = lean_box(0);
+ lean_dec_ref(x_183);
+ x_199 = lean_box(0);
 }
-x_197 = 1;
-if (lean_is_scalar(x_196)) {
- x_198 = lean_alloc_ctor(0, 0, 9);
+x_200 = 1;
+if (lean_is_scalar(x_199)) {
+ x_201 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_198 = x_196;
+ x_201 = x_199;
 }
-lean_ctor_set_uint8(x_198, 0, x_188);
-lean_ctor_set_uint8(x_198, 1, x_189);
-lean_ctor_set_uint8(x_198, 2, x_190);
-lean_ctor_set_uint8(x_198, 3, x_191);
-lean_ctor_set_uint8(x_198, 4, x_192);
-lean_ctor_set_uint8(x_198, 5, x_197);
-lean_ctor_set_uint8(x_198, 6, x_193);
-lean_ctor_set_uint8(x_198, 7, x_194);
-lean_ctor_set_uint8(x_198, 8, x_195);
-if (lean_is_scalar(x_187)) {
- x_199 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set_uint8(x_201, 0, x_190);
+lean_ctor_set_uint8(x_201, 1, x_191);
+lean_ctor_set_uint8(x_201, 2, x_192);
+lean_ctor_set_uint8(x_201, 3, x_193);
+lean_ctor_set_uint8(x_201, 4, x_194);
+lean_ctor_set_uint8(x_201, 5, x_200);
+lean_ctor_set_uint8(x_201, 6, x_195);
+lean_ctor_set_uint8(x_201, 7, x_196);
+lean_ctor_set_uint8(x_201, 8, x_197);
+lean_ctor_set_uint8(x_201, 9, x_198);
+if (lean_is_scalar(x_189)) {
+ x_202 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_199 = x_187;
+ x_202 = x_189;
 }
-lean_ctor_set(x_199, 0, x_198);
-lean_ctor_set(x_199, 1, x_184);
-lean_ctor_set(x_199, 2, x_185);
-lean_ctor_set(x_199, 3, x_186);
-x_200 = l___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___closed__1;
+lean_ctor_set(x_202, 0, x_201);
+lean_ctor_set(x_202, 1, x_186);
+lean_ctor_set(x_202, 2, x_187);
+lean_ctor_set(x_202, 3, x_188);
+x_203 = l___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___closed__1;
 lean_inc(x_6);
 lean_inc(x_4);
-x_201 = l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__2___rarg(x_182, x_2, x_200, x_199, x_4, x_5, x_6, x_183);
-if (lean_obj_tag(x_201) == 0)
+x_204 = l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__2___rarg(x_184, x_2, x_203, x_202, x_4, x_5, x_6, x_185);
+if (lean_obj_tag(x_204) == 0)
 {
-lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; 
-x_202 = lean_ctor_get(x_201, 0);
-lean_inc(x_202);
-x_203 = lean_ctor_get(x_201, 1);
-lean_inc(x_203);
-lean_dec(x_201);
-x_204 = lean_st_ref_get(x_6, x_203);
-lean_dec(x_6);
-x_205 = lean_ctor_get(x_204, 1);
+lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; 
+x_205 = lean_ctor_get(x_204, 0);
 lean_inc(x_205);
+x_206 = lean_ctor_get(x_204, 1);
+lean_inc(x_206);
 lean_dec(x_204);
-x_206 = lean_st_ref_take(x_4, x_205);
-x_207 = lean_ctor_get(x_206, 0);
-lean_inc(x_207);
+x_207 = lean_st_ref_get(x_6, x_206);
+lean_dec(x_6);
 x_208 = lean_ctor_get(x_207, 1);
 lean_inc(x_208);
-x_209 = lean_ctor_get(x_206, 1);
-lean_inc(x_209);
-lean_dec(x_206);
-x_210 = lean_ctor_get(x_207, 0);
+lean_dec(x_207);
+x_209 = lean_st_ref_take(x_4, x_208);
+x_210 = lean_ctor_get(x_209, 0);
 lean_inc(x_210);
-x_211 = lean_ctor_get(x_207, 2);
+x_211 = lean_ctor_get(x_210, 1);
 lean_inc(x_211);
-x_212 = lean_ctor_get(x_207, 3);
+x_212 = lean_ctor_get(x_209, 1);
 lean_inc(x_212);
-if (lean_is_exclusive(x_207)) {
- lean_ctor_release(x_207, 0);
- lean_ctor_release(x_207, 1);
- lean_ctor_release(x_207, 2);
- lean_ctor_release(x_207, 3);
- x_213 = x_207;
-} else {
- lean_dec_ref(x_207);
- x_213 = lean_box(0);
-}
-x_214 = lean_ctor_get(x_208, 0);
+lean_dec(x_209);
+x_213 = lean_ctor_get(x_210, 0);
+lean_inc(x_213);
+x_214 = lean_ctor_get(x_210, 2);
 lean_inc(x_214);
-x_215 = lean_ctor_get(x_208, 2);
+x_215 = lean_ctor_get(x_210, 3);
 lean_inc(x_215);
-x_216 = lean_ctor_get(x_208, 3);
-lean_inc(x_216);
-x_217 = lean_ctor_get(x_208, 4);
+if (lean_is_exclusive(x_210)) {
+ lean_ctor_release(x_210, 0);
+ lean_ctor_release(x_210, 1);
+ lean_ctor_release(x_210, 2);
+ lean_ctor_release(x_210, 3);
+ x_216 = x_210;
+} else {
+ lean_dec_ref(x_210);
+ x_216 = lean_box(0);
+}
+x_217 = lean_ctor_get(x_211, 0);
 lean_inc(x_217);
-x_218 = lean_ctor_get(x_208, 1);
+x_218 = lean_ctor_get(x_211, 2);
 lean_inc(x_218);
-if (lean_is_exclusive(x_208)) {
- lean_ctor_release(x_208, 0);
- lean_ctor_release(x_208, 1);
- lean_ctor_release(x_208, 2);
- lean_ctor_release(x_208, 3);
- lean_ctor_release(x_208, 4);
- x_219 = x_208;
+x_219 = lean_ctor_get(x_211, 3);
+lean_inc(x_219);
+x_220 = lean_ctor_get(x_211, 4);
+lean_inc(x_220);
+x_221 = lean_ctor_get(x_211, 1);
+lean_inc(x_221);
+if (lean_is_exclusive(x_211)) {
+ lean_ctor_release(x_211, 0);
+ lean_ctor_release(x_211, 1);
+ lean_ctor_release(x_211, 2);
+ lean_ctor_release(x_211, 3);
+ lean_ctor_release(x_211, 4);
+ x_222 = x_211;
 } else {
- lean_dec_ref(x_208);
- x_219 = lean_box(0);
+ lean_dec_ref(x_211);
+ x_222 = lean_box(0);
 }
-lean_inc(x_202);
-x_220 = l_Std_PersistentHashMap_insert___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__4(x_218, x_177, x_202);
-if (lean_is_scalar(x_219)) {
- x_221 = lean_alloc_ctor(0, 5, 0);
+lean_inc(x_205);
+x_223 = l_Std_PersistentHashMap_insert___at___private_Lean_Meta_FunInfo_0__Lean_Meta_checkFunInfoCache___spec__4(x_221, x_179, x_205);
+if (lean_is_scalar(x_222)) {
+ x_224 = lean_alloc_ctor(0, 5, 0);
 } else {
- x_221 = x_219;
+ x_224 = x_222;
 }
-lean_ctor_set(x_221, 0, x_214);
-lean_ctor_set(x_221, 1, x_220);
-lean_ctor_set(x_221, 2, x_215);
-lean_ctor_set(x_221, 3, x_216);
-lean_ctor_set(x_221, 4, x_217);
-if (lean_is_scalar(x_213)) {
- x_222 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_224, 0, x_217);
+lean_ctor_set(x_224, 1, x_223);
+lean_ctor_set(x_224, 2, x_218);
+lean_ctor_set(x_224, 3, x_219);
+lean_ctor_set(x_224, 4, x_220);
+if (lean_is_scalar(x_216)) {
+ x_225 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_222 = x_213;
+ x_225 = x_216;
 }
-lean_ctor_set(x_222, 0, x_210);
-lean_ctor_set(x_222, 1, x_221);
-lean_ctor_set(x_222, 2, x_211);
-lean_ctor_set(x_222, 3, x_212);
-x_223 = lean_st_ref_set(x_4, x_222, x_209);
+lean_ctor_set(x_225, 0, x_213);
+lean_ctor_set(x_225, 1, x_224);
+lean_ctor_set(x_225, 2, x_214);
+lean_ctor_set(x_225, 3, x_215);
+x_226 = lean_st_ref_set(x_4, x_225, x_212);
 lean_dec(x_4);
-x_224 = lean_ctor_get(x_223, 1);
-lean_inc(x_224);
-if (lean_is_exclusive(x_223)) {
- lean_ctor_release(x_223, 0);
- lean_ctor_release(x_223, 1);
- x_225 = x_223;
+x_227 = lean_ctor_get(x_226, 1);
+lean_inc(x_227);
+if (lean_is_exclusive(x_226)) {
+ lean_ctor_release(x_226, 0);
+ lean_ctor_release(x_226, 1);
+ x_228 = x_226;
 } else {
- lean_dec_ref(x_223);
- x_225 = lean_box(0);
+ lean_dec_ref(x_226);
+ x_228 = lean_box(0);
 }
-if (lean_is_scalar(x_225)) {
- x_226 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_228)) {
+ x_229 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_226 = x_225;
+ x_229 = x_228;
 }
-lean_ctor_set(x_226, 0, x_202);
-lean_ctor_set(x_226, 1, x_224);
-return x_226;
+lean_ctor_set(x_229, 0, x_205);
+lean_ctor_set(x_229, 1, x_227);
+return x_229;
 }
 else
 {
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; 
-lean_dec(x_177);
+lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; 
+lean_dec(x_179);
 lean_dec(x_6);
 lean_dec(x_4);
-x_227 = lean_ctor_get(x_201, 0);
-lean_inc(x_227);
-x_228 = lean_ctor_get(x_201, 1);
-lean_inc(x_228);
-if (lean_is_exclusive(x_201)) {
- lean_ctor_release(x_201, 0);
- lean_ctor_release(x_201, 1);
- x_229 = x_201;
+x_230 = lean_ctor_get(x_204, 0);
+lean_inc(x_230);
+x_231 = lean_ctor_get(x_204, 1);
+lean_inc(x_231);
+if (lean_is_exclusive(x_204)) {
+ lean_ctor_release(x_204, 0);
+ lean_ctor_release(x_204, 1);
+ x_232 = x_204;
 } else {
- lean_dec_ref(x_201);
- x_229 = lean_box(0);
+ lean_dec_ref(x_204);
+ x_232 = lean_box(0);
 }
-if (lean_is_scalar(x_229)) {
- x_230 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_232)) {
+ x_233 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_230 = x_229;
+ x_233 = x_232;
 }
-lean_ctor_set(x_230, 0, x_227);
-lean_ctor_set(x_230, 1, x_228);
-return x_230;
+lean_ctor_set(x_233, 0, x_230);
+lean_ctor_set(x_233, 1, x_231);
+return x_233;
 }
 }
 else
 {
-lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; 
-lean_dec(x_177);
+lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; 
+lean_dec(x_179);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_231 = lean_ctor_get(x_180, 0);
-lean_inc(x_231);
-x_232 = lean_ctor_get(x_180, 1);
-lean_inc(x_232);
-if (lean_is_exclusive(x_180)) {
- lean_ctor_release(x_180, 0);
- lean_ctor_release(x_180, 1);
- x_233 = x_180;
+x_234 = lean_ctor_get(x_182, 0);
+lean_inc(x_234);
+x_235 = lean_ctor_get(x_182, 1);
+lean_inc(x_235);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_236 = x_182;
 } else {
- lean_dec_ref(x_180);
- x_233 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_236 = lean_box(0);
 }
-if (lean_is_scalar(x_233)) {
- x_234 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_236)) {
+ x_237 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_234 = x_233;
+ x_237 = x_236;
 }
-lean_ctor_set(x_234, 0, x_231);
-lean_ctor_set(x_234, 1, x_232);
-return x_234;
+lean_ctor_set(x_237, 0, x_234);
+lean_ctor_set(x_237, 1, x_235);
+return x_237;
 }
 }
 else
 {
-lean_object* x_235; lean_object* x_236; 
-lean_dec(x_177);
+lean_object* x_238; lean_object* x_239; 
+lean_dec(x_179);
 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_235 = lean_ctor_get(x_179, 0);
-lean_inc(x_235);
-lean_dec(x_179);
-x_236 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_236, 0, x_235);
-lean_ctor_set(x_236, 1, x_174);
-return x_236;
+x_238 = lean_ctor_get(x_181, 0);
+lean_inc(x_238);
+lean_dec(x_181);
+x_239 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_239, 0, x_238);
+lean_ctor_set(x_239, 1, x_176);
+return x_239;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/IndPredBelow.c b/stage0/stdlib/Lean/Meta/IndPredBelow.c
index 33ba988e2a..8491c8b4aa 100644
--- a/stage0/stdlib/Lean/Meta/IndPredBelow.c
+++ b/stage0/stdlib/Lean/Meta/IndPredBelow.c
@@ -19,7 +19,6 @@ lean_object* l_Lean_Meta_withLocalDecls_loop___at_Lean_Meta_IndPredBelow_mkCtorT
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_IndPredBelow_mkCtorType_addHeaderVars___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_IndPredBelow_mkConstructor(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_IndPredBelow_mkBrecOnDecl___closed__1;
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* l_Array_anyMUnsafe_any___at_Lean_Meta_IndPredBelow_proveBrecOn_backwardsChaining___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* l_Lean_Meta_IndPredBelow_mkContext___boxed__const__1;
 lean_object* lean_array_set(lean_object*, lean_object*, lean_object*);
@@ -32,7 +31,6 @@ lean_object* l_Lean_Meta_withLocalDecls_loop___at_Lean_Meta_IndPredBelow_mkCtorT
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_IndPredBelow_mkConstructor___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
 lean_object* l_Lean_Meta_withMVarContext___at_Lean_Meta_admit___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 extern lean_object* l_Lean_Meta_getNondepPropHyps___closed__1;
@@ -51,6 +49,7 @@ lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Meta_IndPredBelow_mkBelow___spe
 extern lean_object* l_Lean_Parser_Syntax_addPrec___closed__2;
 lean_object* l_Lean_Meta_withNewBinderInfos___at_Lean_Meta_IndPredBelow_mkContext_mkHeader___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Lean_Meta_withLocalDecl___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__8___boxed(lean_object*, lean_object*);
@@ -73,6 +72,7 @@ lean_object* l_Array_foldrMUnsafe_fold___at_Lean_Meta_IndPredBelow_mkContext_add
 lean_object* l_Lean_Meta_withLocalDecl___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__7___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_IndPredBelow_mkBrecOnDecl_mkIH___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*);
 extern lean_object* l_Lean_Meta_tryUnificationHints_tryCandidate___closed__3;
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_Meta_IndPredBelow_mkCtorType_checkCount_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withLocalDeclImp___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_IndPredBelow_mkContext_motiveName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -91,7 +91,6 @@ lean_object* lean_st_ref_get(lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedParserDescr___closed__1;
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapIdxM_map___at_Lean_Meta_IndPredBelow_proveBrecOn_induction___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_updatePrefix(lean_object*, lean_object*);
 lean_object* l_Lean_commitWhen___at_Lean_Meta_elimEmptyInductive___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -133,6 +132,7 @@ lean_object* l_Lean_Expr_replaceFVars(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_IndPredBelow_mkContext_motiveName___closed__2;
 lean_object* l_Lean_Meta_IndPredBelow_mkContext(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addTrace___at_Lean_Meta_mkCongrLemma___spec__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_IndPredBelow_mkBelow___closed__7;
 lean_object* l_Lean_Meta_withLocalDecls_loop___at_Lean_Meta_IndPredBelow_mkCtorType_addMotives___spec__3___closed__1;
@@ -10618,7 +10618,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Syntax_addPrec___closed__2;
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -11068,7 +11068,7 @@ x_21 = lean_ctor_get(x_19, 1);
 lean_inc(x_21);
 lean_dec(x_19);
 x_22 = l_Lean_Meta_IndPredBelow_proveBrecOn___closed__2;
-x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_22, x_4, x_5, x_6, x_7, x_21);
+x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_22, x_4, x_5, x_6, x_7, x_21);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -11230,7 +11230,7 @@ x_48 = lean_ctor_get(x_19, 1);
 lean_inc(x_48);
 lean_dec(x_19);
 x_49 = l_Lean_Meta_IndPredBelow_proveBrecOn___closed__2;
-x_50 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_49, x_4, x_5, x_6, x_7, x_48);
+x_50 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_49, x_4, x_5, x_6, x_7, x_48);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -12983,7 +12983,7 @@ static lean_object* _init_l_Lean_Meta_IndPredBelow_mkBelow___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Meta_IndPredBelow_proveBrecOn_closeGoal___rarg___closed__4;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
diff --git a/stage0/stdlib/Lean/Meta/InferType.c b/stage0/stdlib/Lean/Meta/InferType.c
index e0097db501..96f108f549 100644
--- a/stage0/stdlib/Lean/Meta/InferType.c
+++ b/stage0/stdlib/Lean/Meta/InferType.c
@@ -59,7 +59,6 @@ lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_inferTypeImp_infer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___at___private_Lean_Meta_InferType_0__Lean_Meta_checkInferTypeCache___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_inferProjType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_throwTypeExcepted___rarg___closed__1;
 lean_object* l_Lean_Expr_instantiateBetaRevRange_visit_match__1(lean_object*);
 lean_object* l_Lean_Expr_instantiateBetaRevRange_visit___closed__12;
@@ -83,6 +82,7 @@ lean_object* l_Std_HashMapImp_insert___at_Lean_Expr_instantiateBetaRevRange_visi
 lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_isPropQuickApp_match__1(lean_object*);
 lean_object* l_Array_foldrMUnsafe_fold___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_InferType_0__Lean_Meta_inferProjType___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* l_Lean_Expr_instantiateBetaRevRange___closed__6;
 lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3562,7 +3562,7 @@ x_27 = l_Lean_KernelException_toMessageData___closed__15;
 x_28 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_28, 0, x_26);
 lean_ctor_set(x_28, 1, x_27);
-x_29 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_28, x_4, x_5, x_6, x_7, x_20);
+x_29 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_28, x_4, x_5, x_6, x_7, x_20);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3603,7 +3603,7 @@ x_38 = l_Lean_KernelException_toMessageData___closed__15;
 x_39 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_39, 0, x_37);
 lean_ctor_set(x_39, 1, x_38);
-x_40 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_39, x_4, x_5, x_6, x_7, x_20);
+x_40 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_39, x_4, x_5, x_6, x_7, x_20);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3668,7 +3668,7 @@ x_61 = l_Lean_KernelException_toMessageData___closed__15;
 x_62 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_62, 0, x_60);
 lean_ctor_set(x_62, 1, x_61);
-x_63 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_62, x_4, x_5, x_6, x_7, x_45);
+x_63 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_62, x_4, x_5, x_6, x_7, x_45);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3784,7 +3784,7 @@ x_87 = l_Lean_KernelException_toMessageData___closed__15;
 x_88 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_88, 0, x_86);
 lean_ctor_set(x_88, 1, x_87);
-x_89 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_88, x_4, x_5, x_6, x_7, x_82);
+x_89 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_88, x_4, x_5, x_6, x_7, x_82);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3903,7 +3903,7 @@ x_107 = l_Lean_KernelException_toMessageData___closed__15;
 x_108 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_108, 0, x_106);
 lean_ctor_set(x_108, 1, x_107);
-x_109 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_108, x_4, x_5, x_6, x_7, x_102);
+x_109 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_108, x_4, x_5, x_6, x_7, x_102);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3962,7 +3962,7 @@ x_118 = l_Lean_KernelException_toMessageData___closed__15;
 x_119 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_119, 0, x_117);
 lean_ctor_set(x_119, 1, x_118);
-x_120 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_119, x_4, x_5, x_6, x_7, x_20);
+x_120 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_119, x_4, x_5, x_6, x_7, x_20);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3987,7 +3987,7 @@ x_125 = l_Lean_KernelException_toMessageData___closed__15;
 x_126 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_126, 0, x_124);
 lean_ctor_set(x_126, 1, x_125);
-x_127 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_126, x_4, x_5, x_6, x_7, x_20);
+x_127 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_126, x_4, x_5, x_6, x_7, x_20);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -4011,7 +4011,7 @@ x_132 = l_Lean_KernelException_toMessageData___closed__15;
 x_133 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_133, 0, x_131);
 lean_ctor_set(x_133, 1, x_132);
-x_134 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_133, x_4, x_5, x_6, x_7, x_20);
+x_134 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_133, x_4, x_5, x_6, x_7, x_20);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -4035,7 +4035,7 @@ x_139 = l_Lean_KernelException_toMessageData___closed__15;
 x_140 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_140, 0, x_138);
 lean_ctor_set(x_140, 1, x_139);
-x_141 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_140, x_4, x_5, x_6, x_7, x_14);
+x_141 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_140, x_4, x_5, x_6, x_7, x_14);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -7556,7 +7556,7 @@ x_13 = l_Lean_KernelException_toMessageData___closed__15;
 x_14 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_14, 0, x_12);
 lean_ctor_set(x_14, 1, x_13);
-x_15 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_14, x_3, x_4, x_5, x_6, x_7);
+x_15 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_14, x_3, x_4, x_5, x_6, x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
@@ -10852,7 +10852,7 @@ return x_19;
 }
 else
 {
-uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
+uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
 x_20 = lean_ctor_get_uint8(x_8, 0);
 x_21 = lean_ctor_get_uint8(x_8, 1);
 x_22 = lean_ctor_get_uint8(x_8, 2);
@@ -10861,166 +10861,170 @@ x_24 = lean_ctor_get_uint8(x_8, 4);
 x_25 = lean_ctor_get_uint8(x_8, 6);
 x_26 = lean_ctor_get_uint8(x_8, 7);
 x_27 = lean_ctor_get_uint8(x_8, 8);
+x_28 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_28 = 1;
-x_29 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_29, 0, x_20);
-lean_ctor_set_uint8(x_29, 1, x_21);
-lean_ctor_set_uint8(x_29, 2, x_22);
-lean_ctor_set_uint8(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, 4, x_24);
-lean_ctor_set_uint8(x_29, 5, x_28);
-lean_ctor_set_uint8(x_29, 6, x_25);
-lean_ctor_set_uint8(x_29, 7, x_26);
-lean_ctor_set_uint8(x_29, 8, x_27);
-lean_ctor_set(x_2, 0, x_29);
+x_29 = 1;
+x_30 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_30, 0, x_20);
+lean_ctor_set_uint8(x_30, 1, x_21);
+lean_ctor_set_uint8(x_30, 2, x_22);
+lean_ctor_set_uint8(x_30, 3, x_23);
+lean_ctor_set_uint8(x_30, 4, x_24);
+lean_ctor_set_uint8(x_30, 5, x_29);
+lean_ctor_set_uint8(x_30, 6, x_25);
+lean_ctor_set_uint8(x_30, 7, x_26);
+lean_ctor_set_uint8(x_30, 8, x_27);
+lean_ctor_set_uint8(x_30, 9, x_28);
+lean_ctor_set(x_2, 0, x_30);
 lean_inc(x_1);
-x_30 = l_Lean_Meta_inferTypeImp_infer(x_1, x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_30) == 0)
+x_31 = l_Lean_Meta_inferTypeImp_infer(x_1, x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_31) == 0)
 {
-lean_object* x_31; lean_object* x_32; lean_object* 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_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_32 = lean_ctor_get(x_31, 0);
 lean_inc(x_32);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_33 = x_30;
+x_33 = lean_ctor_get(x_31, 1);
+lean_inc(x_33);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_34 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_33 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_34 = lean_box(0);
 }
-if (lean_is_scalar(x_33)) {
- x_34 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_34)) {
+ x_35 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_34 = x_33;
+ x_35 = x_34;
 }
-lean_ctor_set(x_34, 0, x_31);
-lean_ctor_set(x_34, 1, x_32);
-return x_34;
+lean_ctor_set(x_35, 0, x_32);
+lean_ctor_set(x_35, 1, x_33);
+return x_35;
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_35 = lean_ctor_get(x_30, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_30, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_36 = lean_ctor_get(x_31, 0);
 lean_inc(x_36);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_37 = x_30;
+x_37 = lean_ctor_get(x_31, 1);
+lean_inc(x_37);
+if (lean_is_exclusive(x_31)) {
+ lean_ctor_release(x_31, 0);
+ lean_ctor_release(x_31, 1);
+ x_38 = x_31;
 } else {
- lean_dec_ref(x_30);
- x_37 = lean_box(0);
+ lean_dec_ref(x_31);
+ x_38 = lean_box(0);
 }
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_38)) {
+ x_39 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_38 = x_37;
+ x_39 = x_38;
 }
-lean_ctor_set(x_38, 0, x_35);
-lean_ctor_set(x_38, 1, x_36);
-return x_38;
+lean_ctor_set(x_39, 0, x_36);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_39 = lean_ctor_get(x_2, 0);
-x_40 = lean_ctor_get(x_2, 1);
-x_41 = lean_ctor_get(x_2, 2);
-x_42 = lean_ctor_get(x_2, 3);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_40 = lean_ctor_get(x_2, 0);
+x_41 = lean_ctor_get(x_2, 1);
+x_42 = lean_ctor_get(x_2, 2);
+x_43 = lean_ctor_get(x_2, 3);
+lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
 lean_inc(x_40);
-lean_inc(x_39);
 lean_dec(x_2);
-x_43 = lean_ctor_get_uint8(x_39, 0);
-x_44 = lean_ctor_get_uint8(x_39, 1);
-x_45 = lean_ctor_get_uint8(x_39, 2);
-x_46 = lean_ctor_get_uint8(x_39, 3);
-x_47 = lean_ctor_get_uint8(x_39, 4);
-x_48 = lean_ctor_get_uint8(x_39, 6);
-x_49 = lean_ctor_get_uint8(x_39, 7);
-x_50 = lean_ctor_get_uint8(x_39, 8);
-if (lean_is_exclusive(x_39)) {
- x_51 = x_39;
+x_44 = lean_ctor_get_uint8(x_40, 0);
+x_45 = lean_ctor_get_uint8(x_40, 1);
+x_46 = lean_ctor_get_uint8(x_40, 2);
+x_47 = lean_ctor_get_uint8(x_40, 3);
+x_48 = lean_ctor_get_uint8(x_40, 4);
+x_49 = lean_ctor_get_uint8(x_40, 6);
+x_50 = lean_ctor_get_uint8(x_40, 7);
+x_51 = lean_ctor_get_uint8(x_40, 8);
+x_52 = lean_ctor_get_uint8(x_40, 9);
+if (lean_is_exclusive(x_40)) {
+ x_53 = x_40;
 } else {
- lean_dec_ref(x_39);
- x_51 = lean_box(0);
+ lean_dec_ref(x_40);
+ x_53 = lean_box(0);
 }
-x_52 = 1;
-if (lean_is_scalar(x_51)) {
- x_53 = lean_alloc_ctor(0, 0, 9);
+x_54 = 1;
+if (lean_is_scalar(x_53)) {
+ x_55 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_53 = x_51;
+ x_55 = x_53;
 }
-lean_ctor_set_uint8(x_53, 0, x_43);
-lean_ctor_set_uint8(x_53, 1, x_44);
-lean_ctor_set_uint8(x_53, 2, x_45);
-lean_ctor_set_uint8(x_53, 3, x_46);
-lean_ctor_set_uint8(x_53, 4, x_47);
-lean_ctor_set_uint8(x_53, 5, x_52);
-lean_ctor_set_uint8(x_53, 6, x_48);
-lean_ctor_set_uint8(x_53, 7, x_49);
-lean_ctor_set_uint8(x_53, 8, x_50);
-x_54 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_54, 0, x_53);
-lean_ctor_set(x_54, 1, x_40);
-lean_ctor_set(x_54, 2, x_41);
-lean_ctor_set(x_54, 3, x_42);
+lean_ctor_set_uint8(x_55, 0, x_44);
+lean_ctor_set_uint8(x_55, 1, x_45);
+lean_ctor_set_uint8(x_55, 2, x_46);
+lean_ctor_set_uint8(x_55, 3, x_47);
+lean_ctor_set_uint8(x_55, 4, x_48);
+lean_ctor_set_uint8(x_55, 5, x_54);
+lean_ctor_set_uint8(x_55, 6, x_49);
+lean_ctor_set_uint8(x_55, 7, x_50);
+lean_ctor_set_uint8(x_55, 8, x_51);
+lean_ctor_set_uint8(x_55, 9, x_52);
+x_56 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_56, 0, x_55);
+lean_ctor_set(x_56, 1, x_41);
+lean_ctor_set(x_56, 2, x_42);
+lean_ctor_set(x_56, 3, x_43);
 lean_inc(x_1);
-x_55 = l_Lean_Meta_inferTypeImp_infer(x_1, x_1, x_54, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_55) == 0)
+x_57 = l_Lean_Meta_inferTypeImp_infer(x_1, x_1, x_56, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_57) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 1);
-lean_inc(x_57);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_58 = x_55;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_58 = lean_ctor_get(x_57, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_57, 1);
+lean_inc(x_59);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_60 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_58 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_60 = lean_box(0);
 }
-if (lean_is_scalar(x_58)) {
- x_59 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_60)) {
+ x_61 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_59 = x_58;
+ x_61 = x_60;
 }
-lean_ctor_set(x_59, 0, x_56);
-lean_ctor_set(x_59, 1, x_57);
-return x_59;
+lean_ctor_set(x_61, 0, x_58);
+lean_ctor_set(x_61, 1, x_59);
+return x_61;
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_60 = lean_ctor_get(x_55, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_55, 1);
-lean_inc(x_61);
-if (lean_is_exclusive(x_55)) {
- lean_ctor_release(x_55, 0);
- lean_ctor_release(x_55, 1);
- x_62 = x_55;
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_62 = lean_ctor_get(x_57, 0);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_57, 1);
+lean_inc(x_63);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ x_64 = x_57;
 } else {
- lean_dec_ref(x_55);
- x_62 = lean_box(0);
+ lean_dec_ref(x_57);
+ x_64 = lean_box(0);
 }
-if (lean_is_scalar(x_62)) {
- x_63 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_64)) {
+ x_65 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_63 = x_62;
+ x_65 = x_64;
 }
-lean_ctor_set(x_63, 0, x_60);
-lean_ctor_set(x_63, 1, x_61);
-return x_63;
+lean_ctor_set(x_65, 0, x_62);
+lean_ctor_set(x_65, 1, x_63);
+return x_65;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Injective.c b/stage0/stdlib/Lean/Meta/Injective.c
index b56465ba9d..5245781a3d 100644
--- a/stage0/stdlib/Lean/Meta/Injective.c
+++ b/stage0/stdlib/Lean/Meta/Injective.c
@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Meta.Injective
-// Imports: Init Lean.Meta.Tactic.Injection Lean.Meta.Tactic.Apply Lean.Meta.Tactic.Cases Lean.Meta.Tactic.Subst Lean.Meta.Tactic.Simp.Types Lean.Meta.Tactic.Assumption
+// Imports: Init Lean.Meta.Transform Lean.Meta.Tactic.Injection Lean.Meta.Tactic.Apply Lean.Meta.Tactic.Cases Lean.Meta.Tactic.Subst Lean.Meta.Tactic.Simp.Types Lean.Meta.Tactic.Assumption
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -15,10 +15,12 @@ extern "C" {
 #endif
 lean_object* l_Lean_Meta_withNewBinderInfos___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__1;
 size_t l_USize_add(size_t, size_t);
 extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__4;
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__2;
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l_Lean_getConstInfoInduct___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoForKernelRec___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -30,6 +32,7 @@ lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__4;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue_match__2(lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_injTheoremFailureHeader___closed__3;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue_match__1___rarg(lean_object*, lean_object*);
@@ -42,7 +45,6 @@ lean_object* l_Lean_Meta_mkInjectiveTheorems(lean_object*, lean_object*, lean_ob
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedParserDescr___closed__1;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___lambda__4(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_instantiate1(lean_object*, lean_object*);
@@ -54,12 +56,16 @@ lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremType
 lean_object* l_Lean_throwError___at_Lean_Meta_mkInjectiveTheorems___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_casesAnd(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_injTheoremFailureHeader___closed__1;
+lean_object* l_Lean_Meta_elimOptParam(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_solveEqOfCtorEq___closed__2;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_match__1(lean_object*);
+lean_object* l_Lean_Meta_elimOptParam___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue_match__1(lean_object*);
+lean_object* l_Lean_Expr_getRevArg_x21(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withNewBinderInfos___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___spec__3(lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__1;
 lean_object* l_Lean_Meta_mkInjectiveEqTheoremNameFor___closed__1;
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -73,6 +79,7 @@ lean_object* l_Lean_Meta_intro1Core(lean_object*, uint8_t, lean_object*, lean_ob
 lean_object* l_Lean_Meta_mkInjectiveTheoremNameFor___closed__2;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewBinderInfosImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
+extern lean_object* l_Lean_Expr_getOptParamDefault_x3f___closed__2;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__2;
 lean_object* l_Lean_Meta_applyRefl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkInjectiveEqTheoremNameFor___closed__2;
@@ -80,6 +87,7 @@ extern lean_object* l_Lean_Meta_splitAnd___closed__1;
 lean_object* l_Lean_Meta_mkInjectiveTheoremNameFor___closed__1;
 lean_object* l_Lean_Meta_mkInjectiveEqTheoremNameFor(lean_object*);
 lean_object* l_Lean_Meta_mkInjectiveEqTheoremNameFor___boxed(lean_object*);
+lean_object* lean_nat_sub(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_solveSelfMax___closed__1;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_solveEqOfCtorEq_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkAnd_x3f(lean_object*);
@@ -89,6 +97,7 @@ lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2(lean_object*, 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_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__3;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__5;
+extern lean_object* l_Lean_Core_betaReduce___closed__2;
 lean_object* l_Lean_Option_register___at_Std_Format_initFn____x40_Lean_Data_Format___hyg_49____spec__1(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Option_get___at_Lean_ppExpr___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -100,8 +109,8 @@ uint8_t l_Lean_Environment_contains(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_addSimpLemma(lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___lambda__3(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_isAppOfArity(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__4;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_solveEqOfCtorEq_match__1(lean_object*);
 uint8_t l_Lean_isInductivePredicate_visit(lean_object*);
 lean_object* l_List_forIn_loop___at_Lean_Meta_mkInjectiveTheorems___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -111,7 +120,7 @@ extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
 uint8_t l_Array_isEmpty___rarg(lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_solveEqOfCtorEq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_match__3___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__1;
+lean_object* l_Lean_Core_transform___at_Lean_Core_betaReduce___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_injTheoremFailureHeader(lean_object*);
 lean_object* l_Lean_Meta_whnf(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure(lean_object*);
@@ -129,17 +138,17 @@ lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremVa
 lean_object* l_Lean_Meta_mkInjectiveTheoremNameFor(lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_substEqs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_getAppNumArgsAux(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_assumptionCore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386_(lean_object*);
 uint8_t lean_expr_eqv(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkInjectiveTheoremNameFor___boxed(lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheorem(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__3;
 lean_object* l_Lean_Name_append(lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoCtor___at_Lean_Meta_mkInjectiveTheorems___spec__2(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_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__2;
 lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Meta_addPPExplicitToExposeDiff_visit___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__3;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___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*);
 lean_object* l_Lean_throwError___at___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_9181____closed__4;
@@ -162,6 +171,7 @@ lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremType
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___closed__2;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkHEq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_elimOptParam___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkFreshExprSyntheticOpaqueMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_injection(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_7553____closed__4;
@@ -178,6 +188,7 @@ lean_object* l_Lean_mkAppB(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isProp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___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*, lean_object*);
+lean_object* l_Lean_Meta_elimOptParam___closed__1;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -267,6 +278,72 @@ lean_dec(x_1);
 return x_7;
 }
 }
+lean_object* l_Lean_Meta_elimOptParam___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_5 = l_Lean_Expr_getOptParamDefault_x3f___closed__2;
+x_6 = lean_unsigned_to_nat(2u);
+x_7 = l_Lean_Expr_isAppOfArity(x_1, x_5, x_6);
+if (x_7 == 0)
+{
+lean_object* x_8; lean_object* x_9; 
+x_8 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_8, 0, x_1);
+x_9 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_9, 0, x_8);
+lean_ctor_set(x_9, 1, x_4);
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_10 = lean_unsigned_to_nat(0u);
+x_11 = l_Lean_Expr_getAppNumArgsAux(x_1, x_10);
+x_12 = lean_nat_sub(x_11, x_10);
+lean_dec(x_11);
+x_13 = lean_unsigned_to_nat(1u);
+x_14 = lean_nat_sub(x_12, x_13);
+lean_dec(x_12);
+x_15 = l_Lean_Expr_getRevArg_x21(x_1, x_14);
+lean_dec(x_1);
+x_16 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_16, 0, x_15);
+x_17 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_17, 0, x_16);
+lean_ctor_set(x_17, 1, x_4);
+return x_17;
+}
+}
+}
+static lean_object* _init_l_Lean_Meta_elimOptParam___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Meta_elimOptParam___lambda__1___boxed), 4, 0);
+return x_1;
+}
+}
+lean_object* l_Lean_Meta_elimOptParam(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = l_Lean_Meta_elimOptParam___closed__1;
+x_6 = l_Lean_Core_betaReduce___closed__2;
+x_7 = l_Lean_Core_transform___at_Lean_Core_betaReduce___spec__1(x_1, x_5, x_6, x_2, x_3, x_4);
+return x_7;
+}
+}
+lean_object* l_Lean_Meta_elimOptParam___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Lean_Meta_elimOptParam___lambda__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_5;
+}
+}
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -2499,7 +2576,7 @@ return x_14;
 lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
 x_8 = lean_ctor_get(x_1, 0);
 lean_inc(x_8);
 x_9 = lean_ctor_get(x_8, 1);
@@ -2507,18 +2584,61 @@ lean_inc(x_9);
 x_10 = l_List_map___at_Lean_mkConstWithLevelParams___spec__1(x_9);
 x_11 = lean_ctor_get(x_8, 2);
 lean_inc(x_11);
-x_12 = lean_ctor_get(x_1, 3);
-lean_inc(x_12);
-x_13 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_13, 0, x_12);
-x_14 = lean_box(x_2);
-x_15 = lean_alloc_closure((void*)(l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___lambda__4___boxed), 11, 4);
-lean_closure_set(x_15, 0, x_8);
-lean_closure_set(x_15, 1, x_10);
-lean_closure_set(x_15, 2, x_14);
-lean_closure_set(x_15, 3, x_1);
-x_16 = l_Lean_Meta_forallBoundedTelescope___at_Lean_Meta_addPPExplicitToExposeDiff_visit___spec__2___rarg(x_11, x_13, x_15, x_3, x_4, x_5, x_6, x_7);
-return x_16;
+x_12 = l_Lean_Meta_elimOptParam___closed__1;
+x_13 = l_Lean_Core_betaReduce___closed__2;
+lean_inc(x_6);
+lean_inc(x_5);
+x_14 = l_Lean_Core_transform___at_Lean_Core_betaReduce___spec__1(x_11, x_12, x_13, x_5, x_6, x_7);
+if (lean_obj_tag(x_14) == 0)
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_14, 1);
+lean_inc(x_16);
+lean_dec(x_14);
+x_17 = lean_ctor_get(x_1, 3);
+lean_inc(x_17);
+x_18 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_18, 0, x_17);
+x_19 = lean_box(x_2);
+x_20 = lean_alloc_closure((void*)(l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___lambda__4___boxed), 11, 4);
+lean_closure_set(x_20, 0, x_8);
+lean_closure_set(x_20, 1, x_10);
+lean_closure_set(x_20, 2, x_19);
+lean_closure_set(x_20, 3, x_1);
+x_21 = l_Lean_Meta_forallBoundedTelescope___at_Lean_Meta_addPPExplicitToExposeDiff_visit___spec__2___rarg(x_15, x_18, x_20, x_3, x_4, x_5, x_6, x_16);
+return x_21;
+}
+else
+{
+uint8_t x_22; 
+lean_dec(x_10);
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_22 = !lean_is_exclusive(x_14);
+if (x_22 == 0)
+{
+return x_14;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_23 = lean_ctor_get(x_14, 0);
+x_24 = lean_ctor_get(x_14, 1);
+lean_inc(x_24);
+lean_inc(x_23);
+lean_dec(x_14);
+x_25 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_25, 0, x_23);
+lean_ctor_set(x_25, 1, x_24);
+return x_25;
+}
+}
 }
 }
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
@@ -2939,7 +3059,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_Injective_0__Lean_Meta_solveEqOfCtorEq___closed__1;
 x_2 = l___private_Lean_Meta_Injective_0__Lean_Meta_solveEqOfCtorEq___closed__2;
-x_3 = lean_unsigned_to_nat(80u);
+x_3 = lean_unsigned_to_nat(89u);
 x_4 = lean_unsigned_to_nat(30u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -3795,7 +3915,7 @@ x_21 = l_Lean_KernelException_toMessageData___closed__3;
 x_22 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_22, 0, x_20);
 lean_ctor_set(x_22, 1, x_21);
-x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_22, x_4, x_5, x_6, x_7, x_17);
+x_23 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_22, x_4, x_5, x_6, x_7, x_17);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3826,7 +3946,7 @@ x_29 = l_Lean_KernelException_toMessageData___closed__3;
 x_30 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_30, 0, x_28);
 lean_ctor_set(x_30, 1, x_29);
-x_31 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_30, x_4, x_5, x_6, x_7, x_25);
+x_31 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_30, x_4, x_5, x_6, x_7, x_25);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -4146,7 +4266,7 @@ x_87 = l_Lean_KernelException_toMessageData___closed__3;
 x_88 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_88, 0, x_86);
 lean_ctor_set(x_88, 1, x_87);
-x_89 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_88, x_4, x_5, x_6, x_7, x_83);
+x_89 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_88, x_4, x_5, x_6, x_7, x_83);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -4682,7 +4802,7 @@ return x_95;
 }
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4690,17 +4810,17 @@ x_1 = lean_mk_string("genInjectivity");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__2() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__1;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__3() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -4708,13 +4828,13 @@ x_1 = lean_mk_string("generate injectivity theorems for inductive datatype const
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__4() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____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_instInhabitedParserDescr___closed__1;
-x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__3;
+x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__3;
 x_4 = lean_box(x_1);
 x_5 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_5, 0, x_4);
@@ -4723,12 +4843,12 @@ lean_ctor_set(x_5, 2, x_3);
 return x_5;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__2;
-x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__4;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__2;
+x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__4;
 x_4 = l_Lean_Option_register___at_Std_Format_initFn____x40_Lean_Data_Format___hyg_49____spec__1(x_2, x_3, x_1);
 return x_4;
 }
@@ -5589,6 +5709,7 @@ return x_7;
 }
 }
 lean_object* initialize_Init(lean_object*);
+lean_object* initialize_Lean_Meta_Transform(lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Injection(lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Apply(lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Cases(lean_object*);
@@ -5603,6 +5724,9 @@ _G_initialized = true;
 res = initialize_Init(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Meta_Transform(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
 res = initialize_Lean_Meta_Tactic_Injection(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
@@ -5623,6 +5747,8 @@ if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 l_Subarray_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkAnd_x3f___spec__1___closed__1 = _init_l_Subarray_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkAnd_x3f___spec__1___closed__1();
 lean_mark_persistent(l_Subarray_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkAnd_x3f___spec__1___closed__1);
+l_Lean_Meta_elimOptParam___closed__1 = _init_l_Lean_Meta_elimOptParam___closed__1();
+lean_mark_persistent(l_Lean_Meta_elimOptParam___closed__1);
 l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___closed__1 = _init_l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___closed__1();
 lean_mark_persistent(l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___closed__1);
 l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___closed__2 = _init_l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___closed__2();
@@ -5659,15 +5785,15 @@ l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda_
 lean_mark_persistent(l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__4);
 l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__5 = _init_l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__5();
 lean_mark_persistent(l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__1___closed__5);
-l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__1);
-l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__2();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__2);
-l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__3 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__3();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__3);
-l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__4 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__4();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345____closed__4);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1345_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__1);
+l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__2();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__2);
+l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__3 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__3();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__3);
+l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__4 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__4();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386____closed__4);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1386_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Meta_genInjectivity = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Meta_genInjectivity);
diff --git a/stage0/stdlib/Lean/Meta/Instances.c b/stage0/stdlib/Lean/Meta/Instances.c
index 0957145b20..b655d72130 100644
--- a/stage0/stdlib/Lean/Meta/Instances.c
+++ b/stage0/stdlib/Lean/Meta/Instances.c
@@ -184,7 +184,7 @@ lean_object* l___private_Lean_Meta_Instances_0__Lean_Meta_mkInstanceKey___lambda
 lean_object* l_Lean_Meta_defaultInstanceExtension___closed__4;
 size_t l_USize_mul(size_t, size_t);
 lean_object* l_Lean_Meta_addDefaultInstance___lambda__2___closed__7;
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_object* l_Lean_Meta_instInhabitedInstances;
 lean_object* l_Lean_Meta_getGlobalInstancesIndex___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallMetaTelescopeReducing___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -6016,7 +6016,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_511____closed__2;
 x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_511____closed__3;
 x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_511____closed__4;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
diff --git a/stage0/stdlib/Lean/Meta/LevelDefEq.c b/stage0/stdlib/Lean/Meta/LevelDefEq.c
index 010031130d..59589af36a 100644
--- a/stage0/stdlib/Lean/Meta/LevelDefEq.c
+++ b/stage0/stdlib/Lean/Meta/LevelDefEq.c
@@ -15,7 +15,6 @@ extern "C" {
 #endif
 lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__3___closed__4;
 lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_decAux_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* l_Lean_Meta_getResetPostponed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_update_forall(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -48,6 +47,7 @@ lean_object* l_Lean_Meta_isExprDefEq___closed__2;
 lean_object* l_Lean_Meta_checkpointDefEq___at_Lean_Meta_isLevelDefEq___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkLeveErrorMessageCore___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_Meta_saveState___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_mkMaxArgsDiff_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -2033,7 +2033,7 @@ static lean_object* _init_l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postpone
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -28973,7 +28973,7 @@ static lean_object* _init_l_Lean_Meta_isExprDefEq___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Meta_isExprDefEq___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -31001,169 +31001,173 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; 
 x_21 = lean_ctor_get_uint8(x_9, 3);
 x_22 = lean_ctor_get_uint8(x_9, 4);
 x_23 = lean_ctor_get_uint8(x_9, 5);
 x_24 = lean_ctor_get_uint8(x_9, 6);
 x_25 = lean_ctor_get_uint8(x_9, 7);
 x_26 = lean_ctor_get_uint8(x_9, 8);
+x_27 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_27 = 1;
-x_28 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_28, 0, x_27);
-lean_ctor_set_uint8(x_28, 1, x_27);
-lean_ctor_set_uint8(x_28, 2, x_27);
-lean_ctor_set_uint8(x_28, 3, x_21);
-lean_ctor_set_uint8(x_28, 4, x_22);
-lean_ctor_set_uint8(x_28, 5, x_23);
-lean_ctor_set_uint8(x_28, 6, x_24);
-lean_ctor_set_uint8(x_28, 7, x_25);
-lean_ctor_set_uint8(x_28, 8, x_26);
-lean_ctor_set(x_3, 0, x_28);
-x_29 = l_Lean_Meta_isExprDefEq(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_29) == 0)
+x_28 = 1;
+x_29 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_29, 0, x_28);
+lean_ctor_set_uint8(x_29, 1, x_28);
+lean_ctor_set_uint8(x_29, 2, x_28);
+lean_ctor_set_uint8(x_29, 3, x_21);
+lean_ctor_set_uint8(x_29, 4, x_22);
+lean_ctor_set_uint8(x_29, 5, x_23);
+lean_ctor_set_uint8(x_29, 6, x_24);
+lean_ctor_set_uint8(x_29, 7, x_25);
+lean_ctor_set_uint8(x_29, 8, x_26);
+lean_ctor_set_uint8(x_29, 9, x_27);
+lean_ctor_set(x_3, 0, x_29);
+x_30 = l_Lean_Meta_isExprDefEq(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_30; lean_object* x_31; lean_object* 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_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
-if (lean_is_exclusive(x_29)) {
- lean_ctor_release(x_29, 0);
- lean_ctor_release(x_29, 1);
- x_32 = x_29;
+x_32 = lean_ctor_get(x_30, 1);
+lean_inc(x_32);
+if (lean_is_exclusive(x_30)) {
+ lean_ctor_release(x_30, 0);
+ lean_ctor_release(x_30, 1);
+ x_33 = x_30;
 } else {
- lean_dec_ref(x_29);
- x_32 = lean_box(0);
+ lean_dec_ref(x_30);
+ x_33 = lean_box(0);
 }
-if (lean_is_scalar(x_32)) {
- x_33 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_33)) {
+ x_34 = lean_alloc_ctor(0, 2, 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);
-return x_33;
+lean_ctor_set(x_34, 0, x_31);
+lean_ctor_set(x_34, 1, x_32);
+return x_34;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_34 = lean_ctor_get(x_29, 0);
-lean_inc(x_34);
-x_35 = lean_ctor_get(x_29, 1);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+x_35 = lean_ctor_get(x_30, 0);
 lean_inc(x_35);
-if (lean_is_exclusive(x_29)) {
- lean_ctor_release(x_29, 0);
- lean_ctor_release(x_29, 1);
- x_36 = x_29;
+x_36 = lean_ctor_get(x_30, 1);
+lean_inc(x_36);
+if (lean_is_exclusive(x_30)) {
+ lean_ctor_release(x_30, 0);
+ lean_ctor_release(x_30, 1);
+ x_37 = x_30;
 } else {
- lean_dec_ref(x_29);
- x_36 = lean_box(0);
+ lean_dec_ref(x_30);
+ x_37 = lean_box(0);
 }
-if (lean_is_scalar(x_36)) {
- x_37 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_37)) {
+ x_38 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_37 = x_36;
+ x_38 = x_37;
 }
-lean_ctor_set(x_37, 0, x_34);
-lean_ctor_set(x_37, 1, x_35);
-return x_37;
+lean_ctor_set(x_38, 0, x_35);
+lean_ctor_set(x_38, 1, x_36);
+return x_38;
 }
 }
 }
 else
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; lean_object* x_48; uint8_t x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_38 = lean_ctor_get(x_3, 0);
-x_39 = lean_ctor_get(x_3, 1);
-x_40 = lean_ctor_get(x_3, 2);
-x_41 = lean_ctor_get(x_3, 3);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; lean_object* x_50; uint8_t x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_39 = lean_ctor_get(x_3, 0);
+x_40 = lean_ctor_get(x_3, 1);
+x_41 = lean_ctor_get(x_3, 2);
+x_42 = lean_ctor_get(x_3, 3);
+lean_inc(x_42);
 lean_inc(x_41);
 lean_inc(x_40);
 lean_inc(x_39);
-lean_inc(x_38);
 lean_dec(x_3);
-x_42 = lean_ctor_get_uint8(x_38, 3);
-x_43 = lean_ctor_get_uint8(x_38, 4);
-x_44 = lean_ctor_get_uint8(x_38, 5);
-x_45 = lean_ctor_get_uint8(x_38, 6);
-x_46 = lean_ctor_get_uint8(x_38, 7);
-x_47 = lean_ctor_get_uint8(x_38, 8);
-if (lean_is_exclusive(x_38)) {
- x_48 = x_38;
+x_43 = lean_ctor_get_uint8(x_39, 3);
+x_44 = lean_ctor_get_uint8(x_39, 4);
+x_45 = lean_ctor_get_uint8(x_39, 5);
+x_46 = lean_ctor_get_uint8(x_39, 6);
+x_47 = lean_ctor_get_uint8(x_39, 7);
+x_48 = lean_ctor_get_uint8(x_39, 8);
+x_49 = lean_ctor_get_uint8(x_39, 9);
+if (lean_is_exclusive(x_39)) {
+ x_50 = x_39;
 } else {
- lean_dec_ref(x_38);
- x_48 = lean_box(0);
+ lean_dec_ref(x_39);
+ x_50 = lean_box(0);
 }
-x_49 = 1;
-if (lean_is_scalar(x_48)) {
- x_50 = lean_alloc_ctor(0, 0, 9);
+x_51 = 1;
+if (lean_is_scalar(x_50)) {
+ x_52 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_50 = x_48;
+ x_52 = x_50;
 }
-lean_ctor_set_uint8(x_50, 0, x_49);
-lean_ctor_set_uint8(x_50, 1, x_49);
-lean_ctor_set_uint8(x_50, 2, x_49);
-lean_ctor_set_uint8(x_50, 3, x_42);
-lean_ctor_set_uint8(x_50, 4, x_43);
-lean_ctor_set_uint8(x_50, 5, x_44);
-lean_ctor_set_uint8(x_50, 6, x_45);
-lean_ctor_set_uint8(x_50, 7, x_46);
-lean_ctor_set_uint8(x_50, 8, x_47);
-x_51 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_51, 0, x_50);
-lean_ctor_set(x_51, 1, x_39);
-lean_ctor_set(x_51, 2, x_40);
-lean_ctor_set(x_51, 3, x_41);
-x_52 = l_Lean_Meta_isExprDefEq(x_1, x_2, x_51, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_52) == 0)
+lean_ctor_set_uint8(x_52, 0, x_51);
+lean_ctor_set_uint8(x_52, 1, x_51);
+lean_ctor_set_uint8(x_52, 2, x_51);
+lean_ctor_set_uint8(x_52, 3, x_43);
+lean_ctor_set_uint8(x_52, 4, x_44);
+lean_ctor_set_uint8(x_52, 5, x_45);
+lean_ctor_set_uint8(x_52, 6, x_46);
+lean_ctor_set_uint8(x_52, 7, x_47);
+lean_ctor_set_uint8(x_52, 8, x_48);
+lean_ctor_set_uint8(x_52, 9, x_49);
+x_53 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_53, 0, x_52);
+lean_ctor_set(x_53, 1, x_40);
+lean_ctor_set(x_53, 2, x_41);
+lean_ctor_set(x_53, 3, x_42);
+x_54 = l_Lean_Meta_isExprDefEq(x_1, x_2, x_53, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_54) == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_53 = lean_ctor_get(x_52, 0);
-lean_inc(x_53);
-x_54 = lean_ctor_get(x_52, 1);
-lean_inc(x_54);
-if (lean_is_exclusive(x_52)) {
- lean_ctor_release(x_52, 0);
- lean_ctor_release(x_52, 1);
- x_55 = x_52;
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_55 = lean_ctor_get(x_54, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_54, 1);
+lean_inc(x_56);
+if (lean_is_exclusive(x_54)) {
+ lean_ctor_release(x_54, 0);
+ lean_ctor_release(x_54, 1);
+ x_57 = x_54;
 } else {
- lean_dec_ref(x_52);
- x_55 = lean_box(0);
+ lean_dec_ref(x_54);
+ x_57 = lean_box(0);
 }
-if (lean_is_scalar(x_55)) {
- x_56 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_57)) {
+ x_58 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_56 = x_55;
+ x_58 = x_57;
 }
-lean_ctor_set(x_56, 0, x_53);
-lean_ctor_set(x_56, 1, x_54);
-return x_56;
+lean_ctor_set(x_58, 0, x_55);
+lean_ctor_set(x_58, 1, x_56);
+return x_58;
 }
 else
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_57 = lean_ctor_get(x_52, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_52, 1);
-lean_inc(x_58);
-if (lean_is_exclusive(x_52)) {
- lean_ctor_release(x_52, 0);
- lean_ctor_release(x_52, 1);
- x_59 = x_52;
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_59 = lean_ctor_get(x_54, 0);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_54, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_54)) {
+ lean_ctor_release(x_54, 0);
+ lean_ctor_release(x_54, 1);
+ x_61 = x_54;
 } else {
- lean_dec_ref(x_52);
- x_59 = lean_box(0);
+ lean_dec_ref(x_54);
+ x_61 = lean_box(0);
 }
-if (lean_is_scalar(x_59)) {
- x_60 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_61)) {
+ x_62 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_60 = x_59;
+ x_62 = x_61;
 }
-lean_ctor_set(x_60, 0, x_57);
-lean_ctor_set(x_60, 1, x_58);
-return x_60;
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_60);
+return x_62;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Match/CaseValues.c b/stage0/stdlib/Lean/Meta/Match/CaseValues.c
index 6611570d7a..17c33c0908 100644
--- a/stage0/stdlib/Lean/Meta/Match/CaseValues.c
+++ b/stage0/stdlib/Lean/Meta/Match/CaseValues.c
@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* l_Lean_Meta_caseValues_loop(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_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 size_t l_USize_add(size_t, size_t);
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_Meta_withMVarContext___at_Lean_Meta_admit___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -27,6 +26,7 @@ lean_object* l_Lean_Meta_caseValueAux___lambda__3___closed__2;
 lean_object* l_Lean_Meta_caseValueAux___lambda__2___closed__3;
 lean_object* l_Lean_Meta_caseValueAux___lambda__3___closed__4;
 lean_object* l_Lean_Meta_caseValueAux___lambda__3(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_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 extern lean_object* l_Array_empty___closed__1;
 lean_object* l_Lean_Meta_caseValues_loop_match__1(lean_object*);
 lean_object* l_Lean_Meta_instInhabitedCaseValueSubgoal___closed__1;
@@ -503,7 +503,7 @@ static lean_object* _init_l_Lean_Meta_caseValueAux___lambda__3___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = lean_alloc_closure((void*)(l___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_mkAnswer___lambda__2___boxed), 7, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
@@ -681,7 +681,7 @@ if (x_66 == 0)
 lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
 x_67 = lean_ctor_get(x_64, 0);
 x_68 = lean_ctor_get(x_64, 1);
-x_69 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_69 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_inc(x_67);
 x_70 = lean_alloc_closure((void*)(l_Lean_Meta_caseValueAux___lambda__1___boxed), 8, 2);
 lean_closure_set(x_70, 0, x_67);
@@ -779,7 +779,7 @@ x_91 = lean_ctor_get(x_64, 1);
 lean_inc(x_91);
 lean_inc(x_90);
 lean_dec(x_64);
-x_92 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_92 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_inc(x_90);
 x_93 = lean_alloc_closure((void*)(l_Lean_Meta_caseValueAux___lambda__1___boxed), 8, 2);
 lean_closure_set(x_93, 0, x_90);
diff --git a/stage0/stdlib/Lean/Meta/Match/Match.c b/stage0/stdlib/Lean/Meta/Match/Match.c
index 6320024787..513d15eafe 100644
--- a/stage0/stdlib/Lean/Meta/Match/Match.c
+++ b/stage0/stdlib/Lean/Meta/Match/Match.c
@@ -22,7 +22,6 @@ lean_object* l_List_filterMapM_loop___at___private_Lean_Meta_Match_Match_0__Lean
 lean_object* l_Lean_Meta_Match_mkMatcher___lambda__2___closed__1;
 lean_object* l_Lean_Meta_Match_Example_applyFVarSubst(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_List_moveToFront_loop___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_moveToFront___spec__2___closed__1;
 lean_object* l_Lean_Meta_Match_mkMatcher___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* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_List_moveToFront_loop___rarg___boxed(lean_object*, lean_object*, lean_object*);
@@ -116,6 +115,7 @@ lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___
 lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_process_search(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_moveToFront___spec__5(lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_registerExt___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_mkMatcher___lambda__1___closed__7;
 lean_object* l_Lean_Meta_Match_withMkMatcherInput_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -153,7 +153,6 @@ extern lean_object* l_Std_PersistentHashMap_root___default___closed__2;
 uint8_t lean_name_eq(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_checkNumPatterns(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_constructorApp_x3f(lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processConstructor___spec__3___boxed(lean_object*, lean_object*);
 extern lean_object* l_instReprBool___closed__1;
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_throwCasesException___rarg___closed__6;
@@ -222,6 +221,7 @@ lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processConstru
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_throwCasesException___rarg___closed__2;
 lean_object* l_Lean_Meta_Match_withMkMatcherInput___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_fmt___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_unify_x3f___spec__1___boxed(lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processConstructor___boxed__const__1;
 lean_object* l_Lean_Meta_Match_mkMatcher___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -260,6 +260,7 @@ lean_object* l_Lean_Meta_lambdaTelescope___at_Lean_Meta_MatcherApp_addArg___spec
 lean_object* l_List_map___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_expandVarIntoArrayLit_loop___spec__2(lean_object*);
 uint8_t l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_hasVarPattern(lean_object*);
 lean_object* l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3;
 uint8_t l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_isArrayLitTransition(lean_object*);
 uint8_t l_List_foldr___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_hasCtorPattern___spec__1(uint8_t, lean_object*);
 lean_object* l_Lean_ConstantInfo_levelParams(lean_object*);
@@ -382,6 +383,7 @@ lean_object* l_Lean_Meta_MatcherApp_addArg_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_List_moveToFront___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAtCollisionNodeAux___at_Lean_Meta_Match_mkMatcherAuxDefinition___spec__7(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_mkMatcherAuxDefinition_match__1___rarg(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_hasRecursiveType_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_List_moveToFront_loop___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_moveToFront___spec__4(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__1;
@@ -406,7 +408,6 @@ lean_object* l_Lean_Meta_Match_Unify_assign(lean_object*, lean_object*, lean_obj
 lean_object* l_List_foldr___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_inLocalDecls___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 size_t l_Lean_Expr_hash(lean_object*);
 lean_object* l_Lean_Meta_Match_mkMatcher___lambda__4(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_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
 lean_object* l_Lean_Meta_Match_State_counterExamples___default;
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_getUElimPos_x3f___closed__1;
 uint8_t l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_isConstructorTransition(lean_object*);
@@ -570,7 +571,6 @@ extern lean_object* l___private_Lean_Util_Trace_0__Lean_addNode___rarg___lambda_
 uint8_t l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_isValueTransition(lean_object*);
 lean_object* l_List_map___at_Lean_Meta_Match_mkMatcher___spec__1(lean_object*);
 lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processLeaf___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3;
 lean_object* l_Lean_Meta_Match_initFn____x40_Lean_Meta_Match_Match___hyg_6883____lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_withMkMatcherInput___rarg___closed__2;
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_traceState___closed__2;
@@ -1321,7 +1321,7 @@ static lean_object* _init_l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_w
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -1332,7 +1332,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__2;
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__3;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__3;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -24321,7 +24321,7 @@ lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128;
 x_125 = lean_ctor_get(x_119, 1);
 lean_inc(x_125);
 lean_dec(x_119);
-x_126 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_126 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_127 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_126, x_4, x_5, x_6, x_7, x_125);
 x_128 = lean_ctor_get(x_127, 0);
 lean_inc(x_128);
@@ -24471,7 +24471,7 @@ lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean
 x_75 = lean_ctor_get(x_70, 1);
 lean_inc(x_75);
 lean_dec(x_70);
-x_76 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_76 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_77 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_76, x_4, x_5, x_6, x_7, x_75);
 x_78 = lean_ctor_get(x_77, 0);
 lean_inc(x_78);
@@ -24561,7 +24561,7 @@ lean_ctor_set(x_64, 1, x_63);
 x_65 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_65, 0, x_64);
 lean_ctor_set(x_65, 1, x_55);
-x_66 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_66 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_67 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_66, x_65, x_4, x_5, x_6, x_7, x_53);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -24681,7 +24681,7 @@ lean_ctor_set(x_113, 1, x_112);
 x_114 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_114, 0, x_113);
 lean_ctor_set(x_114, 1, x_104);
-x_115 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_115 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_116 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_115, x_114, x_4, x_5, x_6, x_7, x_102);
 x_117 = lean_ctor_get(x_116, 1);
 lean_inc(x_117);
@@ -27527,7 +27527,7 @@ x_14 = lean_ctor_get(x_10, 1);
 lean_inc(x_14);
 lean_dec(x_10);
 x_15 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_updateAlts___lambda__3___closed__2;
-x_16 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_15, x_4, x_5, x_6, x_7, x_14);
+x_16 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_15, x_4, x_5, x_6, x_7, x_14);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
diff --git a/stage0/stdlib/Lean/Meta/Match/MatcherInfo.c b/stage0/stdlib/Lean/Meta/Match/MatcherInfo.c
index d43cf37306..424ccd0055 100644
--- a/stage0/stdlib/Lean/Meta/Match/MatcherInfo.c
+++ b/stage0/stdlib/Lean/Meta/Match/MatcherInfo.c
@@ -97,7 +97,7 @@ extern lean_object* l_Lean_mkEmptyEnvironment___lambda__1___closed__1;
 lean_object* l_Lean_Meta_Match_Extension_addMatcherInfo(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_MatcherInfo_getMotivePos___boxed(lean_object*);
 size_t l_USize_mul(size_t, size_t);
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_Meta_Match_Extension_initFn____x40_Lean_Meta_Match_MatcherInfo___hyg_146____lambda__1___boxed(lean_object*);
 lean_object* l_Std_AssocList_contains___at_Lean_Meta_Match_Extension_State_addEntry___spec__7___boxed(lean_object*, lean_object*);
@@ -1668,7 +1668,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_Meta_Match_Extension_initFn____x40_Lean_Meta_Match_MatcherInfo___hyg_146____closed__2;
 x_2 = l_Lean_Meta_Match_Extension_initFn____x40_Lean_Meta_Match_MatcherInfo___hyg_146____closed__3;
 x_3 = l_Lean_Meta_Match_Extension_initFn____x40_Lean_Meta_Match_MatcherInfo___hyg_146____closed__4;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
diff --git a/stage0/stdlib/Lean/Meta/MatchUtil.c b/stage0/stdlib/Lean/Meta/MatchUtil.c
index 3f707178ee..add313e9ee 100644
--- a/stage0/stdlib/Lean/Meta/MatchUtil.c
+++ b/stage0/stdlib/Lean/Meta/MatchUtil.c
@@ -26,10 +26,10 @@ lean_object* l_Lean_Meta_matchNot_x3f_match__1(lean_object*);
 lean_object* l_Lean_Meta_matchNot_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_testHelper(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*);
-extern lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__4;
 uint8_t l_Lean_Expr_isConstOf(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_matchHelper_x3f(lean_object*);
 lean_object* l_Lean_Meta_whnf(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 lean_object* l_Lean_Meta_matchEq_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_matchConstructorApp_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_matchNe_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1148,7 +1148,7 @@ lean_object* l_Lean_Meta_matchNe_x3f(lean_object* x_1, lean_object* x_2, lean_ob
 _start:
 {
 lean_object* x_7; lean_object* x_8; lean_object* x_72; lean_object* x_73; uint8_t x_74; 
-x_72 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_72 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_73 = lean_unsigned_to_nat(3u);
 x_74 = l_Lean_Expr_isAppOfArity(x_1, x_72, x_73);
 if (x_74 == 0)
@@ -1300,7 +1300,7 @@ if (x_10 == 0)
 lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; 
 x_11 = lean_ctor_get(x_9, 0);
 x_12 = lean_ctor_get(x_9, 1);
-x_13 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_13 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_14 = lean_unsigned_to_nat(3u);
 x_15 = l_Lean_Expr_isAppOfArity(x_11, x_13, x_14);
 if (x_15 == 0)
@@ -1422,7 +1422,7 @@ x_40 = lean_ctor_get(x_9, 1);
 lean_inc(x_40);
 lean_inc(x_39);
 lean_dec(x_9);
-x_41 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_41 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_42 = lean_unsigned_to_nat(3u);
 x_43 = l_Lean_Expr_isAppOfArity(x_39, x_41, x_42);
 if (x_43 == 0)
diff --git a/stage0/stdlib/Lean/Meta/ReduceEval.c b/stage0/stdlib/Lean/Meta/ReduceEval.c
index 636026941f..be8c5dcd00 100644
--- a/stage0/stdlib/Lean/Meta/ReduceEval.c
+++ b/stage0/stdlib/Lean/Meta/ReduceEval.c
@@ -180,7 +180,7 @@ return x_31;
 }
 else
 {
-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; uint8_t x_42; 
+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; uint8_t x_42; uint8_t x_43; 
 x_32 = lean_ctor_get_uint8(x_9, 0);
 x_33 = lean_ctor_get_uint8(x_9, 1);
 x_34 = lean_ctor_get_uint8(x_9, 2);
@@ -190,310 +190,316 @@ x_37 = lean_ctor_get_uint8(x_9, 5);
 x_38 = lean_ctor_get_uint8(x_9, 6);
 x_39 = lean_ctor_get_uint8(x_9, 7);
 x_40 = lean_ctor_get_uint8(x_9, 8);
+x_41 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_41 = 1;
-x_42 = l_Lean_Meta_TransparencyMode_lt(x_37, x_41);
-if (x_42 == 0)
+x_42 = 1;
+x_43 = l_Lean_Meta_TransparencyMode_lt(x_37, x_42);
+if (x_43 == 0)
 {
-lean_object* x_43; lean_object* x_44; 
-x_43 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_43, 0, x_32);
-lean_ctor_set_uint8(x_43, 1, x_33);
-lean_ctor_set_uint8(x_43, 2, x_34);
-lean_ctor_set_uint8(x_43, 3, x_35);
-lean_ctor_set_uint8(x_43, 4, x_36);
-lean_ctor_set_uint8(x_43, 5, x_37);
-lean_ctor_set_uint8(x_43, 6, x_38);
-lean_ctor_set_uint8(x_43, 7, x_39);
-lean_ctor_set_uint8(x_43, 8, x_40);
-lean_ctor_set(x_3, 0, x_43);
-x_44 = lean_apply_6(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_44) == 0)
+lean_object* x_44; lean_object* x_45; 
+x_44 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_44, 0, x_32);
+lean_ctor_set_uint8(x_44, 1, x_33);
+lean_ctor_set_uint8(x_44, 2, x_34);
+lean_ctor_set_uint8(x_44, 3, x_35);
+lean_ctor_set_uint8(x_44, 4, x_36);
+lean_ctor_set_uint8(x_44, 5, x_37);
+lean_ctor_set_uint8(x_44, 6, x_38);
+lean_ctor_set_uint8(x_44, 7, x_39);
+lean_ctor_set_uint8(x_44, 8, x_40);
+lean_ctor_set_uint8(x_44, 9, x_41);
+lean_ctor_set(x_3, 0, x_44);
+x_45 = lean_apply_6(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_45) == 0)
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-x_45 = lean_ctor_get(x_44, 0);
-lean_inc(x_45);
-x_46 = lean_ctor_get(x_44, 1);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_46 = lean_ctor_get(x_45, 0);
 lean_inc(x_46);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- lean_ctor_release(x_44, 1);
- x_47 = x_44;
+x_47 = lean_ctor_get(x_45, 1);
+lean_inc(x_47);
+if (lean_is_exclusive(x_45)) {
+ lean_ctor_release(x_45, 0);
+ lean_ctor_release(x_45, 1);
+ x_48 = x_45;
 } else {
- lean_dec_ref(x_44);
- x_47 = lean_box(0);
+ lean_dec_ref(x_45);
+ x_48 = lean_box(0);
 }
-if (lean_is_scalar(x_47)) {
- x_48 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_48)) {
+ x_49 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_48 = x_47;
+ x_49 = x_48;
 }
-lean_ctor_set(x_48, 0, x_45);
-lean_ctor_set(x_48, 1, x_46);
-return x_48;
+lean_ctor_set(x_49, 0, x_46);
+lean_ctor_set(x_49, 1, x_47);
+return x_49;
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_49 = lean_ctor_get(x_44, 0);
-lean_inc(x_49);
-x_50 = lean_ctor_get(x_44, 1);
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_50 = lean_ctor_get(x_45, 0);
 lean_inc(x_50);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- lean_ctor_release(x_44, 1);
- x_51 = x_44;
+x_51 = lean_ctor_get(x_45, 1);
+lean_inc(x_51);
+if (lean_is_exclusive(x_45)) {
+ lean_ctor_release(x_45, 0);
+ lean_ctor_release(x_45, 1);
+ x_52 = x_45;
 } else {
- lean_dec_ref(x_44);
- x_51 = lean_box(0);
+ lean_dec_ref(x_45);
+ x_52 = lean_box(0);
 }
-if (lean_is_scalar(x_51)) {
- x_52 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_52)) {
+ x_53 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_52 = x_51;
+ x_53 = x_52;
 }
-lean_ctor_set(x_52, 0, x_49);
-lean_ctor_set(x_52, 1, x_50);
-return x_52;
+lean_ctor_set(x_53, 0, x_50);
+lean_ctor_set(x_53, 1, x_51);
+return x_53;
 }
 }
 else
 {
-lean_object* x_53; lean_object* x_54; 
-x_53 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_53, 0, x_32);
-lean_ctor_set_uint8(x_53, 1, x_33);
-lean_ctor_set_uint8(x_53, 2, x_34);
-lean_ctor_set_uint8(x_53, 3, x_35);
-lean_ctor_set_uint8(x_53, 4, x_36);
-lean_ctor_set_uint8(x_53, 5, x_41);
-lean_ctor_set_uint8(x_53, 6, x_38);
-lean_ctor_set_uint8(x_53, 7, x_39);
-lean_ctor_set_uint8(x_53, 8, x_40);
-lean_ctor_set(x_3, 0, x_53);
-x_54 = lean_apply_6(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_54) == 0)
+lean_object* x_54; lean_object* x_55; 
+x_54 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_54, 0, x_32);
+lean_ctor_set_uint8(x_54, 1, x_33);
+lean_ctor_set_uint8(x_54, 2, x_34);
+lean_ctor_set_uint8(x_54, 3, x_35);
+lean_ctor_set_uint8(x_54, 4, x_36);
+lean_ctor_set_uint8(x_54, 5, x_42);
+lean_ctor_set_uint8(x_54, 6, x_38);
+lean_ctor_set_uint8(x_54, 7, x_39);
+lean_ctor_set_uint8(x_54, 8, x_40);
+lean_ctor_set_uint8(x_54, 9, x_41);
+lean_ctor_set(x_3, 0, x_54);
+x_55 = lean_apply_6(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-x_55 = lean_ctor_get(x_54, 0);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_54, 1);
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_56 = lean_ctor_get(x_55, 0);
 lean_inc(x_56);
-if (lean_is_exclusive(x_54)) {
- lean_ctor_release(x_54, 0);
- lean_ctor_release(x_54, 1);
- x_57 = x_54;
+x_57 = lean_ctor_get(x_55, 1);
+lean_inc(x_57);
+if (lean_is_exclusive(x_55)) {
+ lean_ctor_release(x_55, 0);
+ lean_ctor_release(x_55, 1);
+ x_58 = x_55;
 } else {
- lean_dec_ref(x_54);
- x_57 = lean_box(0);
+ lean_dec_ref(x_55);
+ x_58 = lean_box(0);
 }
-if (lean_is_scalar(x_57)) {
- x_58 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_58)) {
+ x_59 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_58 = x_57;
+ x_59 = x_58;
 }
-lean_ctor_set(x_58, 0, x_55);
-lean_ctor_set(x_58, 1, x_56);
-return 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_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-x_59 = lean_ctor_get(x_54, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_54, 1);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_60 = lean_ctor_get(x_55, 0);
 lean_inc(x_60);
-if (lean_is_exclusive(x_54)) {
- lean_ctor_release(x_54, 0);
- lean_ctor_release(x_54, 1);
- x_61 = x_54;
+x_61 = lean_ctor_get(x_55, 1);
+lean_inc(x_61);
+if (lean_is_exclusive(x_55)) {
+ lean_ctor_release(x_55, 0);
+ lean_ctor_release(x_55, 1);
+ x_62 = x_55;
 } else {
- lean_dec_ref(x_54);
- x_61 = lean_box(0);
+ lean_dec_ref(x_55);
+ x_62 = lean_box(0);
 }
-if (lean_is_scalar(x_61)) {
- x_62 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_62)) {
+ x_63 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_62 = x_61;
+ x_63 = x_62;
 }
-lean_ctor_set(x_62, 0, x_59);
-lean_ctor_set(x_62, 1, x_60);
-return x_62;
+lean_ctor_set(x_63, 0, x_60);
+lean_ctor_set(x_63, 1, x_61);
+return x_63;
 }
 }
 }
 }
 else
 {
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* 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; lean_object* x_76; uint8_t x_77; uint8_t x_78; 
-x_63 = lean_ctor_get(x_3, 0);
-x_64 = lean_ctor_get(x_3, 1);
-x_65 = lean_ctor_get(x_3, 2);
-x_66 = lean_ctor_get(x_3, 3);
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* 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; lean_object* x_78; uint8_t x_79; uint8_t x_80; 
+x_64 = lean_ctor_get(x_3, 0);
+x_65 = lean_ctor_get(x_3, 1);
+x_66 = lean_ctor_get(x_3, 2);
+x_67 = lean_ctor_get(x_3, 3);
+lean_inc(x_67);
 lean_inc(x_66);
 lean_inc(x_65);
 lean_inc(x_64);
-lean_inc(x_63);
 lean_dec(x_3);
-x_67 = lean_ctor_get_uint8(x_63, 0);
-x_68 = lean_ctor_get_uint8(x_63, 1);
-x_69 = lean_ctor_get_uint8(x_63, 2);
-x_70 = lean_ctor_get_uint8(x_63, 3);
-x_71 = lean_ctor_get_uint8(x_63, 4);
-x_72 = lean_ctor_get_uint8(x_63, 5);
-x_73 = lean_ctor_get_uint8(x_63, 6);
-x_74 = lean_ctor_get_uint8(x_63, 7);
-x_75 = lean_ctor_get_uint8(x_63, 8);
-if (lean_is_exclusive(x_63)) {
- x_76 = x_63;
+x_68 = lean_ctor_get_uint8(x_64, 0);
+x_69 = lean_ctor_get_uint8(x_64, 1);
+x_70 = lean_ctor_get_uint8(x_64, 2);
+x_71 = lean_ctor_get_uint8(x_64, 3);
+x_72 = lean_ctor_get_uint8(x_64, 4);
+x_73 = lean_ctor_get_uint8(x_64, 5);
+x_74 = lean_ctor_get_uint8(x_64, 6);
+x_75 = lean_ctor_get_uint8(x_64, 7);
+x_76 = lean_ctor_get_uint8(x_64, 8);
+x_77 = lean_ctor_get_uint8(x_64, 9);
+if (lean_is_exclusive(x_64)) {
+ x_78 = x_64;
 } else {
- lean_dec_ref(x_63);
- x_76 = lean_box(0);
+ lean_dec_ref(x_64);
+ x_78 = lean_box(0);
 }
-x_77 = 1;
-x_78 = l_Lean_Meta_TransparencyMode_lt(x_72, x_77);
-if (x_78 == 0)
+x_79 = 1;
+x_80 = l_Lean_Meta_TransparencyMode_lt(x_73, x_79);
+if (x_80 == 0)
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-if (lean_is_scalar(x_76)) {
- x_79 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+if (lean_is_scalar(x_78)) {
+ x_81 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_79 = x_76;
+ x_81 = x_78;
 }
-lean_ctor_set_uint8(x_79, 0, x_67);
-lean_ctor_set_uint8(x_79, 1, x_68);
-lean_ctor_set_uint8(x_79, 2, x_69);
-lean_ctor_set_uint8(x_79, 3, x_70);
-lean_ctor_set_uint8(x_79, 4, x_71);
-lean_ctor_set_uint8(x_79, 5, x_72);
-lean_ctor_set_uint8(x_79, 6, x_73);
-lean_ctor_set_uint8(x_79, 7, x_74);
-lean_ctor_set_uint8(x_79, 8, x_75);
-x_80 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_80, 1, x_64);
-lean_ctor_set(x_80, 2, x_65);
-lean_ctor_set(x_80, 3, x_66);
-x_81 = lean_apply_6(x_1, x_2, x_80, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_81) == 0)
+lean_ctor_set_uint8(x_81, 0, x_68);
+lean_ctor_set_uint8(x_81, 1, x_69);
+lean_ctor_set_uint8(x_81, 2, x_70);
+lean_ctor_set_uint8(x_81, 3, x_71);
+lean_ctor_set_uint8(x_81, 4, x_72);
+lean_ctor_set_uint8(x_81, 5, x_73);
+lean_ctor_set_uint8(x_81, 6, x_74);
+lean_ctor_set_uint8(x_81, 7, x_75);
+lean_ctor_set_uint8(x_81, 8, x_76);
+lean_ctor_set_uint8(x_81, 9, x_77);
+x_82 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_82, 0, x_81);
+lean_ctor_set(x_82, 1, x_65);
+lean_ctor_set(x_82, 2, x_66);
+lean_ctor_set(x_82, 3, x_67);
+x_83 = lean_apply_6(x_1, x_2, x_82, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_83) == 0)
 {
-lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_82 = lean_ctor_get(x_81, 0);
-lean_inc(x_82);
-x_83 = lean_ctor_get(x_81, 1);
-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;
+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);
+if (lean_is_exclusive(x_83)) {
+ lean_ctor_release(x_83, 0);
+ lean_ctor_release(x_83, 1);
+ x_86 = x_83;
 } else {
- lean_dec_ref(x_81);
- x_84 = lean_box(0);
+ lean_dec_ref(x_83);
+ x_86 = lean_box(0);
 }
-if (lean_is_scalar(x_84)) {
- x_85 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_86)) {
+ x_87 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_85 = x_84;
+ x_87 = x_86;
 }
-lean_ctor_set(x_85, 0, x_82);
-lean_ctor_set(x_85, 1, x_83);
-return x_85;
+lean_ctor_set(x_87, 0, x_84);
+lean_ctor_set(x_87, 1, x_85);
+return x_87;
 }
 else
 {
-lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
-x_86 = lean_ctor_get(x_81, 0);
-lean_inc(x_86);
-x_87 = lean_ctor_get(x_81, 1);
-lean_inc(x_87);
-if (lean_is_exclusive(x_81)) {
- lean_ctor_release(x_81, 0);
- lean_ctor_release(x_81, 1);
- x_88 = x_81;
+lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
+x_88 = lean_ctor_get(x_83, 0);
+lean_inc(x_88);
+x_89 = lean_ctor_get(x_83, 1);
+lean_inc(x_89);
+if (lean_is_exclusive(x_83)) {
+ lean_ctor_release(x_83, 0);
+ lean_ctor_release(x_83, 1);
+ x_90 = x_83;
 } else {
- lean_dec_ref(x_81);
- x_88 = lean_box(0);
+ lean_dec_ref(x_83);
+ x_90 = lean_box(0);
 }
-if (lean_is_scalar(x_88)) {
- x_89 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_90)) {
+ x_91 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_89 = x_88;
+ x_91 = x_90;
 }
-lean_ctor_set(x_89, 0, x_86);
-lean_ctor_set(x_89, 1, x_87);
-return x_89;
+lean_ctor_set(x_91, 0, x_88);
+lean_ctor_set(x_91, 1, x_89);
+return x_91;
 }
 }
 else
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-if (lean_is_scalar(x_76)) {
- x_90 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_92; lean_object* x_93; lean_object* x_94; 
+if (lean_is_scalar(x_78)) {
+ x_92 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_90 = x_76;
+ x_92 = x_78;
 }
-lean_ctor_set_uint8(x_90, 0, x_67);
-lean_ctor_set_uint8(x_90, 1, x_68);
-lean_ctor_set_uint8(x_90, 2, x_69);
-lean_ctor_set_uint8(x_90, 3, x_70);
-lean_ctor_set_uint8(x_90, 4, x_71);
-lean_ctor_set_uint8(x_90, 5, x_77);
-lean_ctor_set_uint8(x_90, 6, x_73);
-lean_ctor_set_uint8(x_90, 7, x_74);
-lean_ctor_set_uint8(x_90, 8, x_75);
-x_91 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_64);
-lean_ctor_set(x_91, 2, x_65);
-lean_ctor_set(x_91, 3, x_66);
-x_92 = lean_apply_6(x_1, x_2, x_91, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_92) == 0)
+lean_ctor_set_uint8(x_92, 0, x_68);
+lean_ctor_set_uint8(x_92, 1, x_69);
+lean_ctor_set_uint8(x_92, 2, x_70);
+lean_ctor_set_uint8(x_92, 3, x_71);
+lean_ctor_set_uint8(x_92, 4, x_72);
+lean_ctor_set_uint8(x_92, 5, x_79);
+lean_ctor_set_uint8(x_92, 6, x_74);
+lean_ctor_set_uint8(x_92, 7, x_75);
+lean_ctor_set_uint8(x_92, 8, x_76);
+lean_ctor_set_uint8(x_92, 9, x_77);
+x_93 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_93, 0, x_92);
+lean_ctor_set(x_93, 1, x_65);
+lean_ctor_set(x_93, 2, x_66);
+lean_ctor_set(x_93, 3, x_67);
+x_94 = lean_apply_6(x_1, x_2, x_93, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_94) == 0)
 {
-lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; 
-x_93 = lean_ctor_get(x_92, 0);
-lean_inc(x_93);
-x_94 = lean_ctor_get(x_92, 1);
-lean_inc(x_94);
-if (lean_is_exclusive(x_92)) {
- lean_ctor_release(x_92, 0);
- lean_ctor_release(x_92, 1);
- x_95 = x_92;
+lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
+x_95 = lean_ctor_get(x_94, 0);
+lean_inc(x_95);
+x_96 = lean_ctor_get(x_94, 1);
+lean_inc(x_96);
+if (lean_is_exclusive(x_94)) {
+ lean_ctor_release(x_94, 0);
+ lean_ctor_release(x_94, 1);
+ x_97 = x_94;
 } else {
- lean_dec_ref(x_92);
- x_95 = lean_box(0);
+ lean_dec_ref(x_94);
+ x_97 = lean_box(0);
 }
-if (lean_is_scalar(x_95)) {
- x_96 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_97)) {
+ x_98 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_96 = x_95;
+ x_98 = x_97;
 }
-lean_ctor_set(x_96, 0, x_93);
-lean_ctor_set(x_96, 1, x_94);
-return x_96;
+lean_ctor_set(x_98, 0, x_95);
+lean_ctor_set(x_98, 1, x_96);
+return x_98;
 }
 else
 {
-lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 
-x_97 = lean_ctor_get(x_92, 0);
-lean_inc(x_97);
-x_98 = lean_ctor_get(x_92, 1);
-lean_inc(x_98);
-if (lean_is_exclusive(x_92)) {
- lean_ctor_release(x_92, 0);
- lean_ctor_release(x_92, 1);
- x_99 = x_92;
+lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+x_99 = lean_ctor_get(x_94, 0);
+lean_inc(x_99);
+x_100 = lean_ctor_get(x_94, 1);
+lean_inc(x_100);
+if (lean_is_exclusive(x_94)) {
+ lean_ctor_release(x_94, 0);
+ lean_ctor_release(x_94, 1);
+ x_101 = x_94;
 } else {
- lean_dec_ref(x_92);
- x_99 = lean_box(0);
+ lean_dec_ref(x_94);
+ x_101 = lean_box(0);
 }
-if (lean_is_scalar(x_99)) {
- x_100 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_101)) {
+ x_102 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_100 = x_99;
+ x_102 = x_101;
 }
-lean_ctor_set(x_100, 0, x_97);
-lean_ctor_set(x_100, 1, x_98);
-return x_100;
+lean_ctor_set(x_102, 0, x_99);
+lean_ctor_set(x_102, 1, x_100);
+return x_102;
 }
 }
 }
@@ -1831,7 +1837,7 @@ return x_62;
 }
 else
 {
-uint8_t x_63; uint8_t x_64; uint8_t 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_63; uint8_t x_64; uint8_t 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; 
 x_63 = lean_ctor_get_uint8(x_8, 0);
 x_64 = lean_ctor_get_uint8(x_8, 1);
 x_65 = lean_ctor_get_uint8(x_8, 2);
@@ -1841,694 +1847,700 @@ x_68 = lean_ctor_get_uint8(x_8, 5);
 x_69 = lean_ctor_get_uint8(x_8, 6);
 x_70 = lean_ctor_get_uint8(x_8, 7);
 x_71 = lean_ctor_get_uint8(x_8, 8);
+x_72 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_72 = 1;
-x_73 = l_Lean_Meta_TransparencyMode_lt(x_68, x_72);
-if (x_73 == 0)
+x_73 = 1;
+x_74 = l_Lean_Meta_TransparencyMode_lt(x_68, x_73);
+if (x_74 == 0)
 {
-lean_object* x_74; lean_object* x_75; 
-x_74 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_74, 0, x_63);
-lean_ctor_set_uint8(x_74, 1, x_64);
-lean_ctor_set_uint8(x_74, 2, x_65);
-lean_ctor_set_uint8(x_74, 3, x_66);
-lean_ctor_set_uint8(x_74, 4, x_67);
-lean_ctor_set_uint8(x_74, 5, x_68);
-lean_ctor_set_uint8(x_74, 6, x_69);
-lean_ctor_set_uint8(x_74, 7, x_70);
-lean_ctor_set_uint8(x_74, 8, x_71);
-lean_ctor_set(x_2, 0, x_74);
+lean_object* x_75; lean_object* x_76; 
+x_75 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_75, 0, x_63);
+lean_ctor_set_uint8(x_75, 1, x_64);
+lean_ctor_set_uint8(x_75, 2, x_65);
+lean_ctor_set_uint8(x_75, 3, x_66);
+lean_ctor_set_uint8(x_75, 4, x_67);
+lean_ctor_set_uint8(x_75, 5, x_68);
+lean_ctor_set_uint8(x_75, 6, x_69);
+lean_ctor_set_uint8(x_75, 7, x_70);
+lean_ctor_set_uint8(x_75, 8, x_71);
+lean_ctor_set_uint8(x_75, 9, x_72);
+lean_ctor_set(x_2, 0, x_75);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-x_75 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_75) == 0)
+x_76 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_76) == 0)
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; 
-x_76 = lean_ctor_get(x_75, 0);
-lean_inc(x_76);
-x_77 = lean_ctor_get(x_75, 1);
+lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+x_77 = lean_ctor_get(x_76, 0);
 lean_inc(x_77);
-lean_dec(x_75);
+x_78 = lean_ctor_get(x_76, 1);
+lean_inc(x_78);
+lean_dec(x_76);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-lean_inc(x_76);
-x_78 = l_Lean_Meta_evalNat(x_76, x_2, x_3, x_4, x_5, x_77);
-if (lean_obj_tag(x_78) == 0)
-{
-lean_object* x_79; 
-x_79 = lean_ctor_get(x_78, 0);
-lean_inc(x_79);
+lean_inc(x_77);
+x_79 = l_Lean_Meta_evalNat(x_77, x_2, x_3, x_4, x_5, x_78);
 if (lean_obj_tag(x_79) == 0)
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_80 = lean_ctor_get(x_78, 1);
+lean_object* x_80; 
+x_80 = lean_ctor_get(x_79, 0);
 lean_inc(x_80);
-lean_dec(x_78);
-x_81 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_76, x_2, x_3, x_4, x_5, x_80);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_82 = lean_ctor_get(x_81, 0);
-lean_inc(x_82);
-x_83 = lean_ctor_get(x_81, 1);
-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;
-} else {
- lean_dec_ref(x_81);
- x_84 = lean_box(0);
-}
-if (lean_is_scalar(x_84)) {
- x_85 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_85 = x_84;
-}
-lean_ctor_set(x_85, 0, x_82);
-lean_ctor_set(x_85, 1, x_83);
-return x_85;
-}
-else
+if (lean_obj_tag(x_80) == 0)
 {
-lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
-lean_dec(x_76);
-lean_dec(x_2);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_86 = lean_ctor_get(x_78, 1);
-lean_inc(x_86);
-if (lean_is_exclusive(x_78)) {
- lean_ctor_release(x_78, 0);
- lean_ctor_release(x_78, 1);
- x_87 = x_78;
-} else {
- lean_dec_ref(x_78);
- x_87 = lean_box(0);
-}
-x_88 = lean_ctor_get(x_79, 0);
-lean_inc(x_88);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+x_81 = lean_ctor_get(x_79, 1);
+lean_inc(x_81);
 lean_dec(x_79);
-if (lean_is_scalar(x_87)) {
- x_89 = lean_alloc_ctor(0, 2, 0);
+x_82 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_77, x_2, x_3, x_4, x_5, x_81);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_83 = lean_ctor_get(x_82, 0);
+lean_inc(x_83);
+x_84 = lean_ctor_get(x_82, 1);
+lean_inc(x_84);
+if (lean_is_exclusive(x_82)) {
+ lean_ctor_release(x_82, 0);
+ lean_ctor_release(x_82, 1);
+ x_85 = x_82;
 } else {
- x_89 = x_87;
+ lean_dec_ref(x_82);
+ x_85 = lean_box(0);
 }
-lean_ctor_set(x_89, 0, x_88);
-lean_ctor_set(x_89, 1, x_86);
-return x_89;
+if (lean_is_scalar(x_85)) {
+ x_86 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_86 = x_85;
 }
+lean_ctor_set(x_86, 0, x_83);
+lean_ctor_set(x_86, 1, x_84);
+return x_86;
 }
 else
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; 
-lean_dec(x_76);
+lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
+lean_dec(x_77);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_90 = lean_ctor_get(x_78, 0);
-lean_inc(x_90);
-x_91 = lean_ctor_get(x_78, 1);
+x_87 = lean_ctor_get(x_79, 1);
+lean_inc(x_87);
+if (lean_is_exclusive(x_79)) {
+ lean_ctor_release(x_79, 0);
+ lean_ctor_release(x_79, 1);
+ x_88 = x_79;
+} else {
+ lean_dec_ref(x_79);
+ x_88 = lean_box(0);
+}
+x_89 = lean_ctor_get(x_80, 0);
+lean_inc(x_89);
+lean_dec(x_80);
+if (lean_is_scalar(x_88)) {
+ x_90 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_90 = x_88;
+}
+lean_ctor_set(x_90, 0, x_89);
+lean_ctor_set(x_90, 1, x_87);
+return x_90;
+}
+}
+else
+{
+lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; 
+lean_dec(x_77);
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_91 = lean_ctor_get(x_79, 0);
 lean_inc(x_91);
-if (lean_is_exclusive(x_78)) {
- lean_ctor_release(x_78, 0);
- lean_ctor_release(x_78, 1);
- x_92 = x_78;
+x_92 = lean_ctor_get(x_79, 1);
+lean_inc(x_92);
+if (lean_is_exclusive(x_79)) {
+ lean_ctor_release(x_79, 0);
+ lean_ctor_release(x_79, 1);
+ x_93 = x_79;
 } else {
- lean_dec_ref(x_78);
- x_92 = lean_box(0);
+ lean_dec_ref(x_79);
+ x_93 = lean_box(0);
 }
-if (lean_is_scalar(x_92)) {
- x_93 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_93)) {
+ x_94 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_93 = x_92;
+ x_94 = x_93;
 }
-lean_ctor_set(x_93, 0, x_90);
-lean_ctor_set(x_93, 1, x_91);
-return x_93;
+lean_ctor_set(x_94, 0, x_91);
+lean_ctor_set(x_94, 1, x_92);
+return x_94;
 }
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; 
+lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_94 = lean_ctor_get(x_75, 0);
-lean_inc(x_94);
-x_95 = lean_ctor_get(x_75, 1);
+x_95 = lean_ctor_get(x_76, 0);
 lean_inc(x_95);
-if (lean_is_exclusive(x_75)) {
- lean_ctor_release(x_75, 0);
- lean_ctor_release(x_75, 1);
- x_96 = x_75;
+x_96 = lean_ctor_get(x_76, 1);
+lean_inc(x_96);
+if (lean_is_exclusive(x_76)) {
+ lean_ctor_release(x_76, 0);
+ lean_ctor_release(x_76, 1);
+ x_97 = x_76;
 } else {
- lean_dec_ref(x_75);
- x_96 = lean_box(0);
+ lean_dec_ref(x_76);
+ x_97 = lean_box(0);
 }
-if (lean_is_scalar(x_96)) {
- x_97 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_97)) {
+ x_98 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_97 = x_96;
+ x_98 = x_97;
 }
-lean_ctor_set(x_97, 0, x_94);
-lean_ctor_set(x_97, 1, x_95);
-return x_97;
+lean_ctor_set(x_98, 0, x_95);
+lean_ctor_set(x_98, 1, x_96);
+return x_98;
 }
 }
 else
 {
-lean_object* x_98; lean_object* x_99; 
-x_98 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_98, 0, x_63);
-lean_ctor_set_uint8(x_98, 1, x_64);
-lean_ctor_set_uint8(x_98, 2, x_65);
-lean_ctor_set_uint8(x_98, 3, x_66);
-lean_ctor_set_uint8(x_98, 4, x_67);
-lean_ctor_set_uint8(x_98, 5, x_72);
-lean_ctor_set_uint8(x_98, 6, x_69);
-lean_ctor_set_uint8(x_98, 7, x_70);
-lean_ctor_set_uint8(x_98, 8, x_71);
-lean_ctor_set(x_2, 0, x_98);
+lean_object* x_99; lean_object* x_100; 
+x_99 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_99, 0, x_63);
+lean_ctor_set_uint8(x_99, 1, x_64);
+lean_ctor_set_uint8(x_99, 2, x_65);
+lean_ctor_set_uint8(x_99, 3, x_66);
+lean_ctor_set_uint8(x_99, 4, x_67);
+lean_ctor_set_uint8(x_99, 5, x_73);
+lean_ctor_set_uint8(x_99, 6, x_69);
+lean_ctor_set_uint8(x_99, 7, x_70);
+lean_ctor_set_uint8(x_99, 8, x_71);
+lean_ctor_set_uint8(x_99, 9, x_72);
+lean_ctor_set(x_2, 0, x_99);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-x_99 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_99) == 0)
+x_100 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_100) == 0)
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; 
-x_100 = lean_ctor_get(x_99, 0);
-lean_inc(x_100);
-x_101 = lean_ctor_get(x_99, 1);
+lean_object* x_101; lean_object* x_102; lean_object* x_103; 
+x_101 = lean_ctor_get(x_100, 0);
 lean_inc(x_101);
-lean_dec(x_99);
+x_102 = lean_ctor_get(x_100, 1);
+lean_inc(x_102);
+lean_dec(x_100);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-lean_inc(x_100);
-x_102 = l_Lean_Meta_evalNat(x_100, x_2, x_3, x_4, x_5, x_101);
-if (lean_obj_tag(x_102) == 0)
-{
-lean_object* x_103; 
-x_103 = lean_ctor_get(x_102, 0);
-lean_inc(x_103);
+lean_inc(x_101);
+x_103 = l_Lean_Meta_evalNat(x_101, x_2, x_3, x_4, x_5, x_102);
 if (lean_obj_tag(x_103) == 0)
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; 
-x_104 = lean_ctor_get(x_102, 1);
+lean_object* x_104; 
+x_104 = lean_ctor_get(x_103, 0);
 lean_inc(x_104);
-lean_dec(x_102);
-x_105 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_100, x_2, x_3, x_4, x_5, x_104);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_106 = lean_ctor_get(x_105, 0);
-lean_inc(x_106);
-x_107 = lean_ctor_get(x_105, 1);
-lean_inc(x_107);
-if (lean_is_exclusive(x_105)) {
- lean_ctor_release(x_105, 0);
- lean_ctor_release(x_105, 1);
- x_108 = x_105;
-} else {
- lean_dec_ref(x_105);
- x_108 = lean_box(0);
-}
-if (lean_is_scalar(x_108)) {
- x_109 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_109 = x_108;
-}
-lean_ctor_set(x_109, 0, x_106);
-lean_ctor_set(x_109, 1, x_107);
-return x_109;
-}
-else
+if (lean_obj_tag(x_104) == 0)
 {
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; 
-lean_dec(x_100);
-lean_dec(x_2);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_110 = lean_ctor_get(x_102, 1);
-lean_inc(x_110);
-if (lean_is_exclusive(x_102)) {
- lean_ctor_release(x_102, 0);
- lean_ctor_release(x_102, 1);
- x_111 = x_102;
-} else {
- lean_dec_ref(x_102);
- x_111 = lean_box(0);
-}
-x_112 = lean_ctor_get(x_103, 0);
-lean_inc(x_112);
+lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; 
+x_105 = lean_ctor_get(x_103, 1);
+lean_inc(x_105);
 lean_dec(x_103);
-if (lean_is_scalar(x_111)) {
- x_113 = lean_alloc_ctor(0, 2, 0);
+x_106 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_101, x_2, x_3, x_4, x_5, x_105);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_107 = lean_ctor_get(x_106, 0);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_106, 1);
+lean_inc(x_108);
+if (lean_is_exclusive(x_106)) {
+ lean_ctor_release(x_106, 0);
+ lean_ctor_release(x_106, 1);
+ x_109 = x_106;
 } else {
- x_113 = x_111;
+ lean_dec_ref(x_106);
+ x_109 = lean_box(0);
 }
-lean_ctor_set(x_113, 0, x_112);
-lean_ctor_set(x_113, 1, x_110);
-return x_113;
+if (lean_is_scalar(x_109)) {
+ x_110 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_110 = x_109;
 }
+lean_ctor_set(x_110, 0, x_107);
+lean_ctor_set(x_110, 1, x_108);
+return x_110;
 }
 else
 {
-lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
-lean_dec(x_100);
+lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; 
+lean_dec(x_101);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_114 = lean_ctor_get(x_102, 0);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_102, 1);
+x_111 = lean_ctor_get(x_103, 1);
+lean_inc(x_111);
+if (lean_is_exclusive(x_103)) {
+ lean_ctor_release(x_103, 0);
+ lean_ctor_release(x_103, 1);
+ x_112 = x_103;
+} else {
+ lean_dec_ref(x_103);
+ x_112 = lean_box(0);
+}
+x_113 = lean_ctor_get(x_104, 0);
+lean_inc(x_113);
+lean_dec(x_104);
+if (lean_is_scalar(x_112)) {
+ x_114 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_114 = x_112;
+}
+lean_ctor_set(x_114, 0, x_113);
+lean_ctor_set(x_114, 1, x_111);
+return x_114;
+}
+}
+else
+{
+lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
+lean_dec(x_101);
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_115 = lean_ctor_get(x_103, 0);
 lean_inc(x_115);
-if (lean_is_exclusive(x_102)) {
- lean_ctor_release(x_102, 0);
- lean_ctor_release(x_102, 1);
- x_116 = x_102;
+x_116 = lean_ctor_get(x_103, 1);
+lean_inc(x_116);
+if (lean_is_exclusive(x_103)) {
+ lean_ctor_release(x_103, 0);
+ lean_ctor_release(x_103, 1);
+ x_117 = x_103;
 } else {
- lean_dec_ref(x_102);
- x_116 = lean_box(0);
+ lean_dec_ref(x_103);
+ x_117 = lean_box(0);
 }
-if (lean_is_scalar(x_116)) {
- x_117 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_117)) {
+ x_118 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_117 = x_116;
+ x_118 = x_117;
 }
-lean_ctor_set(x_117, 0, x_114);
-lean_ctor_set(x_117, 1, x_115);
-return x_117;
+lean_ctor_set(x_118, 0, x_115);
+lean_ctor_set(x_118, 1, x_116);
+return x_118;
 }
 }
 else
 {
-lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; 
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_118 = lean_ctor_get(x_99, 0);
-lean_inc(x_118);
-x_119 = lean_ctor_get(x_99, 1);
+x_119 = lean_ctor_get(x_100, 0);
 lean_inc(x_119);
-if (lean_is_exclusive(x_99)) {
- lean_ctor_release(x_99, 0);
- lean_ctor_release(x_99, 1);
- x_120 = x_99;
+x_120 = lean_ctor_get(x_100, 1);
+lean_inc(x_120);
+if (lean_is_exclusive(x_100)) {
+ lean_ctor_release(x_100, 0);
+ lean_ctor_release(x_100, 1);
+ x_121 = x_100;
 } else {
- lean_dec_ref(x_99);
- x_120 = lean_box(0);
+ lean_dec_ref(x_100);
+ x_121 = lean_box(0);
 }
-if (lean_is_scalar(x_120)) {
- x_121 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_121)) {
+ x_122 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_121 = x_120;
+ x_122 = x_121;
 }
-lean_ctor_set(x_121, 0, x_118);
-lean_ctor_set(x_121, 1, x_119);
-return x_121;
+lean_ctor_set(x_122, 0, x_119);
+lean_ctor_set(x_122, 1, x_120);
+return x_122;
 }
 }
 }
 }
 else
 {
-lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; uint8_t x_127; uint8_t x_128; uint8_t x_129; uint8_t x_130; uint8_t x_131; uint8_t x_132; uint8_t x_133; uint8_t x_134; lean_object* x_135; uint8_t x_136; uint8_t x_137; 
-x_122 = lean_ctor_get(x_2, 0);
-x_123 = lean_ctor_get(x_2, 1);
-x_124 = lean_ctor_get(x_2, 2);
-x_125 = lean_ctor_get(x_2, 3);
+lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; uint8_t x_128; uint8_t x_129; uint8_t x_130; uint8_t x_131; uint8_t x_132; uint8_t x_133; uint8_t x_134; uint8_t x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; uint8_t x_139; 
+x_123 = lean_ctor_get(x_2, 0);
+x_124 = lean_ctor_get(x_2, 1);
+x_125 = lean_ctor_get(x_2, 2);
+x_126 = lean_ctor_get(x_2, 3);
+lean_inc(x_126);
 lean_inc(x_125);
 lean_inc(x_124);
 lean_inc(x_123);
-lean_inc(x_122);
 lean_dec(x_2);
-x_126 = lean_ctor_get_uint8(x_122, 0);
-x_127 = lean_ctor_get_uint8(x_122, 1);
-x_128 = lean_ctor_get_uint8(x_122, 2);
-x_129 = lean_ctor_get_uint8(x_122, 3);
-x_130 = lean_ctor_get_uint8(x_122, 4);
-x_131 = lean_ctor_get_uint8(x_122, 5);
-x_132 = lean_ctor_get_uint8(x_122, 6);
-x_133 = lean_ctor_get_uint8(x_122, 7);
-x_134 = lean_ctor_get_uint8(x_122, 8);
-if (lean_is_exclusive(x_122)) {
- x_135 = x_122;
+x_127 = lean_ctor_get_uint8(x_123, 0);
+x_128 = lean_ctor_get_uint8(x_123, 1);
+x_129 = lean_ctor_get_uint8(x_123, 2);
+x_130 = lean_ctor_get_uint8(x_123, 3);
+x_131 = lean_ctor_get_uint8(x_123, 4);
+x_132 = lean_ctor_get_uint8(x_123, 5);
+x_133 = lean_ctor_get_uint8(x_123, 6);
+x_134 = lean_ctor_get_uint8(x_123, 7);
+x_135 = lean_ctor_get_uint8(x_123, 8);
+x_136 = lean_ctor_get_uint8(x_123, 9);
+if (lean_is_exclusive(x_123)) {
+ x_137 = x_123;
 } else {
- lean_dec_ref(x_122);
- x_135 = lean_box(0);
+ lean_dec_ref(x_123);
+ x_137 = lean_box(0);
 }
-x_136 = 1;
-x_137 = l_Lean_Meta_TransparencyMode_lt(x_131, x_136);
-if (x_137 == 0)
+x_138 = 1;
+x_139 = l_Lean_Meta_TransparencyMode_lt(x_132, x_138);
+if (x_139 == 0)
 {
-lean_object* x_138; lean_object* x_139; lean_object* x_140; 
-if (lean_is_scalar(x_135)) {
- x_138 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_140; lean_object* x_141; lean_object* x_142; 
+if (lean_is_scalar(x_137)) {
+ x_140 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_138 = x_135;
+ x_140 = x_137;
 }
-lean_ctor_set_uint8(x_138, 0, x_126);
-lean_ctor_set_uint8(x_138, 1, x_127);
-lean_ctor_set_uint8(x_138, 2, x_128);
-lean_ctor_set_uint8(x_138, 3, x_129);
-lean_ctor_set_uint8(x_138, 4, x_130);
-lean_ctor_set_uint8(x_138, 5, x_131);
-lean_ctor_set_uint8(x_138, 6, x_132);
-lean_ctor_set_uint8(x_138, 7, x_133);
-lean_ctor_set_uint8(x_138, 8, x_134);
-x_139 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_139, 0, x_138);
-lean_ctor_set(x_139, 1, x_123);
-lean_ctor_set(x_139, 2, x_124);
-lean_ctor_set(x_139, 3, x_125);
+lean_ctor_set_uint8(x_140, 0, x_127);
+lean_ctor_set_uint8(x_140, 1, x_128);
+lean_ctor_set_uint8(x_140, 2, x_129);
+lean_ctor_set_uint8(x_140, 3, x_130);
+lean_ctor_set_uint8(x_140, 4, x_131);
+lean_ctor_set_uint8(x_140, 5, x_132);
+lean_ctor_set_uint8(x_140, 6, x_133);
+lean_ctor_set_uint8(x_140, 7, x_134);
+lean_ctor_set_uint8(x_140, 8, x_135);
+lean_ctor_set_uint8(x_140, 9, x_136);
+x_141 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_141, 0, x_140);
+lean_ctor_set(x_141, 1, x_124);
+lean_ctor_set(x_141, 2, x_125);
+lean_ctor_set(x_141, 3, x_126);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_139);
-x_140 = l_Lean_Meta_whnf(x_1, x_139, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_140) == 0)
-{
-lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_141 = lean_ctor_get(x_140, 0);
 lean_inc(x_141);
-x_142 = lean_ctor_get(x_140, 1);
-lean_inc(x_142);
-lean_dec(x_140);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_3);
-lean_inc(x_139);
-lean_inc(x_141);
-x_143 = l_Lean_Meta_evalNat(x_141, x_139, x_3, x_4, x_5, x_142);
-if (lean_obj_tag(x_143) == 0)
+x_142 = l_Lean_Meta_whnf(x_1, x_141, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_142) == 0)
 {
-lean_object* x_144; 
-x_144 = lean_ctor_get(x_143, 0);
+lean_object* x_143; lean_object* x_144; lean_object* x_145; 
+x_143 = lean_ctor_get(x_142, 0);
+lean_inc(x_143);
+x_144 = lean_ctor_get(x_142, 1);
 lean_inc(x_144);
-if (lean_obj_tag(x_144) == 0)
+lean_dec(x_142);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_141);
+lean_inc(x_143);
+x_145 = l_Lean_Meta_evalNat(x_143, x_141, x_3, x_4, x_5, x_144);
+if (lean_obj_tag(x_145) == 0)
 {
-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_145 = lean_ctor_get(x_143, 1);
-lean_inc(x_145);
-lean_dec(x_143);
-x_146 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_141, x_139, x_3, x_4, x_5, x_145);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_139);
-x_147 = lean_ctor_get(x_146, 0);
+lean_object* x_146; 
+x_146 = lean_ctor_get(x_145, 0);
+lean_inc(x_146);
+if (lean_obj_tag(x_146) == 0)
+{
+lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
+x_147 = lean_ctor_get(x_145, 1);
 lean_inc(x_147);
-x_148 = lean_ctor_get(x_146, 1);
-lean_inc(x_148);
-if (lean_is_exclusive(x_146)) {
- lean_ctor_release(x_146, 0);
- lean_ctor_release(x_146, 1);
- x_149 = x_146;
-} else {
- lean_dec_ref(x_146);
- 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(x_150, 0, x_147);
-lean_ctor_set(x_150, 1, x_148);
-return x_150;
-}
-else
-{
-lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; 
-lean_dec(x_141);
-lean_dec(x_139);
+lean_dec(x_145);
+x_148 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_143, x_141, x_3, x_4, x_5, x_147);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_151 = lean_ctor_get(x_143, 1);
-lean_inc(x_151);
-if (lean_is_exclusive(x_143)) {
- lean_ctor_release(x_143, 0);
- lean_ctor_release(x_143, 1);
- x_152 = x_143;
+lean_dec(x_141);
+x_149 = lean_ctor_get(x_148, 0);
+lean_inc(x_149);
+x_150 = lean_ctor_get(x_148, 1);
+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;
 } else {
- lean_dec_ref(x_143);
- x_152 = lean_box(0);
+ lean_dec_ref(x_148);
+ x_151 = lean_box(0);
 }
-x_153 = lean_ctor_get(x_144, 0);
+if (lean_is_scalar(x_151)) {
+ x_152 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_152 = x_151;
+}
+lean_ctor_set(x_152, 0, x_149);
+lean_ctor_set(x_152, 1, x_150);
+return x_152;
+}
+else
+{
+lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; 
+lean_dec(x_143);
+lean_dec(x_141);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_153 = lean_ctor_get(x_145, 1);
 lean_inc(x_153);
-lean_dec(x_144);
-if (lean_is_scalar(x_152)) {
- x_154 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_exclusive(x_145)) {
+ lean_ctor_release(x_145, 0);
+ lean_ctor_release(x_145, 1);
+ x_154 = x_145;
 } else {
- x_154 = x_152;
+ lean_dec_ref(x_145);
+ x_154 = lean_box(0);
 }
-lean_ctor_set(x_154, 0, x_153);
-lean_ctor_set(x_154, 1, x_151);
-return x_154;
-}
-}
-else
-{
-lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; 
-lean_dec(x_141);
-lean_dec(x_139);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_155 = lean_ctor_get(x_143, 0);
+x_155 = lean_ctor_get(x_146, 0);
 lean_inc(x_155);
-x_156 = lean_ctor_get(x_143, 1);
-lean_inc(x_156);
-if (lean_is_exclusive(x_143)) {
- lean_ctor_release(x_143, 0);
- lean_ctor_release(x_143, 1);
- x_157 = x_143;
+lean_dec(x_146);
+if (lean_is_scalar(x_154)) {
+ x_156 = lean_alloc_ctor(0, 2, 0);
 } else {
- lean_dec_ref(x_143);
- x_157 = lean_box(0);
+ x_156 = x_154;
 }
-if (lean_is_scalar(x_157)) {
- x_158 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_158 = x_157;
-}
-lean_ctor_set(x_158, 0, x_155);
-lean_ctor_set(x_158, 1, x_156);
-return x_158;
+lean_ctor_set(x_156, 0, x_155);
+lean_ctor_set(x_156, 1, x_153);
+return x_156;
 }
 }
 else
 {
-lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
-lean_dec(x_139);
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; 
+lean_dec(x_143);
+lean_dec(x_141);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_159 = lean_ctor_get(x_140, 0);
-lean_inc(x_159);
-x_160 = lean_ctor_get(x_140, 1);
-lean_inc(x_160);
-if (lean_is_exclusive(x_140)) {
- lean_ctor_release(x_140, 0);
- lean_ctor_release(x_140, 1);
- x_161 = x_140;
+x_157 = lean_ctor_get(x_145, 0);
+lean_inc(x_157);
+x_158 = lean_ctor_get(x_145, 1);
+lean_inc(x_158);
+if (lean_is_exclusive(x_145)) {
+ lean_ctor_release(x_145, 0);
+ lean_ctor_release(x_145, 1);
+ x_159 = x_145;
 } else {
- lean_dec_ref(x_140);
- x_161 = lean_box(0);
+ lean_dec_ref(x_145);
+ x_159 = lean_box(0);
 }
-if (lean_is_scalar(x_161)) {
- x_162 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_159)) {
+ x_160 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_162 = x_161;
+ x_160 = x_159;
 }
-lean_ctor_set(x_162, 0, x_159);
-lean_ctor_set(x_162, 1, x_160);
-return x_162;
+lean_ctor_set(x_160, 0, x_157);
+lean_ctor_set(x_160, 1, x_158);
+return x_160;
 }
 }
 else
 {
-lean_object* x_163; lean_object* x_164; lean_object* x_165; 
-if (lean_is_scalar(x_135)) {
- x_163 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; 
+lean_dec(x_141);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_161 = lean_ctor_get(x_142, 0);
+lean_inc(x_161);
+x_162 = lean_ctor_get(x_142, 1);
+lean_inc(x_162);
+if (lean_is_exclusive(x_142)) {
+ lean_ctor_release(x_142, 0);
+ lean_ctor_release(x_142, 1);
+ x_163 = x_142;
 } else {
- x_163 = x_135;
+ lean_dec_ref(x_142);
+ x_163 = lean_box(0);
 }
-lean_ctor_set_uint8(x_163, 0, x_126);
-lean_ctor_set_uint8(x_163, 1, x_127);
-lean_ctor_set_uint8(x_163, 2, x_128);
-lean_ctor_set_uint8(x_163, 3, x_129);
-lean_ctor_set_uint8(x_163, 4, x_130);
-lean_ctor_set_uint8(x_163, 5, x_136);
-lean_ctor_set_uint8(x_163, 6, x_132);
-lean_ctor_set_uint8(x_163, 7, x_133);
-lean_ctor_set_uint8(x_163, 8, x_134);
-x_164 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_164, 0, x_163);
-lean_ctor_set(x_164, 1, x_123);
-lean_ctor_set(x_164, 2, x_124);
-lean_ctor_set(x_164, 3, x_125);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_161);
+lean_ctor_set(x_164, 1, x_162);
+return x_164;
+}
+}
+else
+{
+lean_object* x_165; lean_object* x_166; lean_object* x_167; 
+if (lean_is_scalar(x_137)) {
+ x_165 = lean_alloc_ctor(0, 0, 10);
+} else {
+ x_165 = x_137;
+}
+lean_ctor_set_uint8(x_165, 0, x_127);
+lean_ctor_set_uint8(x_165, 1, x_128);
+lean_ctor_set_uint8(x_165, 2, x_129);
+lean_ctor_set_uint8(x_165, 3, x_130);
+lean_ctor_set_uint8(x_165, 4, x_131);
+lean_ctor_set_uint8(x_165, 5, x_138);
+lean_ctor_set_uint8(x_165, 6, x_133);
+lean_ctor_set_uint8(x_165, 7, x_134);
+lean_ctor_set_uint8(x_165, 8, x_135);
+lean_ctor_set_uint8(x_165, 9, x_136);
+x_166 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_166, 0, x_165);
+lean_ctor_set(x_166, 1, x_124);
+lean_ctor_set(x_166, 2, x_125);
+lean_ctor_set(x_166, 3, x_126);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_164);
-x_165 = l_Lean_Meta_whnf(x_1, x_164, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_165) == 0)
-{
-lean_object* x_166; lean_object* x_167; lean_object* x_168; 
-x_166 = lean_ctor_get(x_165, 0);
 lean_inc(x_166);
-x_167 = lean_ctor_get(x_165, 1);
-lean_inc(x_167);
-lean_dec(x_165);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_3);
-lean_inc(x_164);
-lean_inc(x_166);
-x_168 = l_Lean_Meta_evalNat(x_166, x_164, x_3, x_4, x_5, x_167);
-if (lean_obj_tag(x_168) == 0)
+x_167 = l_Lean_Meta_whnf(x_1, x_166, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_167) == 0)
 {
-lean_object* x_169; 
-x_169 = lean_ctor_get(x_168, 0);
+lean_object* x_168; lean_object* x_169; lean_object* x_170; 
+x_168 = lean_ctor_get(x_167, 0);
+lean_inc(x_168);
+x_169 = lean_ctor_get(x_167, 1);
 lean_inc(x_169);
-if (lean_obj_tag(x_169) == 0)
+lean_dec(x_167);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_166);
+lean_inc(x_168);
+x_170 = l_Lean_Meta_evalNat(x_168, x_166, x_3, x_4, x_5, x_169);
+if (lean_obj_tag(x_170) == 0)
 {
-lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; 
-x_170 = lean_ctor_get(x_168, 1);
-lean_inc(x_170);
-lean_dec(x_168);
-x_171 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_166, x_164, x_3, x_4, x_5, x_170);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_164);
-x_172 = lean_ctor_get(x_171, 0);
+lean_object* x_171; 
+x_171 = lean_ctor_get(x_170, 0);
+lean_inc(x_171);
+if (lean_obj_tag(x_171) == 0)
+{
+lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; 
+x_172 = lean_ctor_get(x_170, 1);
 lean_inc(x_172);
-x_173 = lean_ctor_get(x_171, 1);
-lean_inc(x_173);
-if (lean_is_exclusive(x_171)) {
- lean_ctor_release(x_171, 0);
- lean_ctor_release(x_171, 1);
- x_174 = x_171;
-} else {
- lean_dec_ref(x_171);
- x_174 = lean_box(0);
-}
-if (lean_is_scalar(x_174)) {
- x_175 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_175 = x_174;
-}
-lean_ctor_set(x_175, 0, x_172);
-lean_ctor_set(x_175, 1, x_173);
-return x_175;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; 
-lean_dec(x_166);
-lean_dec(x_164);
+lean_dec(x_170);
+x_173 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_168, x_166, x_3, x_4, x_5, x_172);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_176 = lean_ctor_get(x_168, 1);
-lean_inc(x_176);
-if (lean_is_exclusive(x_168)) {
- lean_ctor_release(x_168, 0);
- lean_ctor_release(x_168, 1);
- x_177 = x_168;
+lean_dec(x_166);
+x_174 = lean_ctor_get(x_173, 0);
+lean_inc(x_174);
+x_175 = lean_ctor_get(x_173, 1);
+lean_inc(x_175);
+if (lean_is_exclusive(x_173)) {
+ lean_ctor_release(x_173, 0);
+ lean_ctor_release(x_173, 1);
+ x_176 = x_173;
 } else {
- lean_dec_ref(x_168);
- x_177 = lean_box(0);
+ lean_dec_ref(x_173);
+ x_176 = lean_box(0);
 }
-x_178 = lean_ctor_get(x_169, 0);
+if (lean_is_scalar(x_176)) {
+ x_177 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_177 = x_176;
+}
+lean_ctor_set(x_177, 0, x_174);
+lean_ctor_set(x_177, 1, x_175);
+return x_177;
+}
+else
+{
+lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; 
+lean_dec(x_168);
+lean_dec(x_166);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_178 = lean_ctor_get(x_170, 1);
 lean_inc(x_178);
-lean_dec(x_169);
-if (lean_is_scalar(x_177)) {
- x_179 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_exclusive(x_170)) {
+ lean_ctor_release(x_170, 0);
+ lean_ctor_release(x_170, 1);
+ x_179 = x_170;
 } else {
- x_179 = x_177;
+ lean_dec_ref(x_170);
+ x_179 = lean_box(0);
 }
-lean_ctor_set(x_179, 0, x_178);
-lean_ctor_set(x_179, 1, x_176);
-return x_179;
-}
-}
-else
-{
-lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; 
-lean_dec(x_166);
-lean_dec(x_164);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_180 = lean_ctor_get(x_168, 0);
+x_180 = lean_ctor_get(x_171, 0);
 lean_inc(x_180);
-x_181 = lean_ctor_get(x_168, 1);
-lean_inc(x_181);
-if (lean_is_exclusive(x_168)) {
- lean_ctor_release(x_168, 0);
- lean_ctor_release(x_168, 1);
- x_182 = x_168;
+lean_dec(x_171);
+if (lean_is_scalar(x_179)) {
+ x_181 = lean_alloc_ctor(0, 2, 0);
 } else {
- lean_dec_ref(x_168);
- x_182 = lean_box(0);
+ x_181 = x_179;
 }
-if (lean_is_scalar(x_182)) {
- x_183 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_183 = x_182;
-}
-lean_ctor_set(x_183, 0, x_180);
-lean_ctor_set(x_183, 1, x_181);
-return x_183;
+lean_ctor_set(x_181, 0, x_180);
+lean_ctor_set(x_181, 1, x_178);
+return x_181;
 }
 }
 else
 {
-lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; 
-lean_dec(x_164);
+lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; 
+lean_dec(x_168);
+lean_dec(x_166);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_184 = lean_ctor_get(x_165, 0);
-lean_inc(x_184);
-x_185 = lean_ctor_get(x_165, 1);
-lean_inc(x_185);
-if (lean_is_exclusive(x_165)) {
- lean_ctor_release(x_165, 0);
- lean_ctor_release(x_165, 1);
- x_186 = x_165;
+x_182 = lean_ctor_get(x_170, 0);
+lean_inc(x_182);
+x_183 = lean_ctor_get(x_170, 1);
+lean_inc(x_183);
+if (lean_is_exclusive(x_170)) {
+ lean_ctor_release(x_170, 0);
+ lean_ctor_release(x_170, 1);
+ x_184 = x_170;
 } else {
- lean_dec_ref(x_165);
- x_186 = lean_box(0);
+ lean_dec_ref(x_170);
+ x_184 = lean_box(0);
 }
-if (lean_is_scalar(x_186)) {
- x_187 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_184)) {
+ x_185 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_187 = x_186;
+ x_185 = x_184;
 }
-lean_ctor_set(x_187, 0, x_184);
-lean_ctor_set(x_187, 1, x_185);
-return x_187;
+lean_ctor_set(x_185, 0, x_182);
+lean_ctor_set(x_185, 1, x_183);
+return x_185;
+}
+}
+else
+{
+lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; 
+lean_dec(x_166);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_186 = lean_ctor_get(x_167, 0);
+lean_inc(x_186);
+x_187 = lean_ctor_get(x_167, 1);
+lean_inc(x_187);
+if (lean_is_exclusive(x_167)) {
+ lean_ctor_release(x_167, 0);
+ lean_ctor_release(x_167, 1);
+ x_188 = x_167;
+} else {
+ lean_dec_ref(x_167);
+ x_188 = lean_box(0);
+}
+if (lean_is_scalar(x_188)) {
+ x_189 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_189 = x_188;
+}
+lean_ctor_set(x_189, 0, x_186);
+lean_ctor_set(x_189, 1, x_187);
+return x_189;
 }
 }
 }
@@ -2792,7 +2804,7 @@ goto block_16;
 }
 else
 {
-uint8_t x_57; uint8_t x_58; uint8_t x_59; uint8_t x_60; uint8_t x_61; uint8_t x_62; uint8_t x_63; uint8_t x_64; uint8_t x_65; uint8_t x_66; uint8_t x_67; 
+uint8_t x_57; uint8_t x_58; uint8_t x_59; uint8_t x_60; uint8_t x_61; uint8_t x_62; uint8_t x_63; uint8_t x_64; uint8_t x_65; uint8_t x_66; uint8_t x_67; uint8_t x_68; 
 x_57 = lean_ctor_get_uint8(x_18, 0);
 x_58 = lean_ctor_get_uint8(x_18, 1);
 x_59 = lean_ctor_get_uint8(x_18, 2);
@@ -2802,256 +2814,259 @@ x_62 = lean_ctor_get_uint8(x_18, 5);
 x_63 = lean_ctor_get_uint8(x_18, 6);
 x_64 = lean_ctor_get_uint8(x_18, 7);
 x_65 = lean_ctor_get_uint8(x_18, 8);
+x_66 = lean_ctor_get_uint8(x_18, 9);
 lean_dec(x_18);
-x_66 = 1;
-x_67 = l_Lean_Meta_TransparencyMode_lt(x_62, x_66);
-if (x_67 == 0)
+x_67 = 1;
+x_68 = l_Lean_Meta_TransparencyMode_lt(x_62, x_67);
+if (x_68 == 0)
 {
-lean_object* x_68; lean_object* x_69; 
-x_68 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_68, 0, x_57);
-lean_ctor_set_uint8(x_68, 1, x_58);
-lean_ctor_set_uint8(x_68, 2, x_59);
-lean_ctor_set_uint8(x_68, 3, x_60);
-lean_ctor_set_uint8(x_68, 4, x_61);
-lean_ctor_set_uint8(x_68, 5, x_62);
-lean_ctor_set_uint8(x_68, 6, x_63);
-lean_ctor_set_uint8(x_68, 7, x_64);
-lean_ctor_set_uint8(x_68, 8, x_65);
-lean_ctor_set(x_2, 0, x_68);
+lean_object* x_69; lean_object* x_70; 
+x_69 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_69, 0, x_57);
+lean_ctor_set_uint8(x_69, 1, x_58);
+lean_ctor_set_uint8(x_69, 2, x_59);
+lean_ctor_set_uint8(x_69, 3, x_60);
+lean_ctor_set_uint8(x_69, 4, x_61);
+lean_ctor_set_uint8(x_69, 5, x_62);
+lean_ctor_set_uint8(x_69, 6, x_63);
+lean_ctor_set_uint8(x_69, 7, x_64);
+lean_ctor_set_uint8(x_69, 8, x_65);
+lean_ctor_set_uint8(x_69, 9, x_66);
+lean_ctor_set(x_2, 0, x_69);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
 lean_inc(x_1);
-x_69 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_69) == 0)
-{
-lean_object* x_70; 
-x_70 = lean_ctor_get(x_69, 0);
-lean_inc(x_70);
-if (lean_obj_tag(x_70) == 9)
+x_70 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_70) == 0)
 {
 lean_object* x_71; 
 x_71 = lean_ctor_get(x_70, 0);
 lean_inc(x_71);
-lean_dec(x_70);
-if (lean_obj_tag(x_71) == 0)
+if (lean_obj_tag(x_71) == 9)
 {
-lean_object* x_72; lean_object* x_73; 
-lean_dec(x_71);
-x_72 = lean_ctor_get(x_69, 1);
+lean_object* x_72; 
+x_72 = lean_ctor_get(x_71, 0);
 lean_inc(x_72);
-lean_dec(x_69);
-x_73 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_72);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_7 = x_73;
-goto block_16;
-}
-else
-{
-lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
-lean_dec(x_2);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_74 = lean_ctor_get(x_69, 1);
-lean_inc(x_74);
-if (lean_is_exclusive(x_69)) {
- lean_ctor_release(x_69, 0);
- lean_ctor_release(x_69, 1);
- x_75 = x_69;
-} else {
- lean_dec_ref(x_69);
- x_75 = lean_box(0);
-}
-x_76 = lean_ctor_get(x_71, 0);
-lean_inc(x_76);
 lean_dec(x_71);
-if (lean_is_scalar(x_75)) {
- x_77 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_77 = x_75;
-}
-lean_ctor_set(x_77, 0, x_76);
-lean_ctor_set(x_77, 1, x_74);
-x_7 = x_77;
-goto block_16;
-}
-}
-else
+if (lean_obj_tag(x_72) == 0)
 {
-lean_object* x_78; lean_object* x_79; 
+lean_object* x_73; lean_object* x_74; 
+lean_dec(x_72);
+x_73 = lean_ctor_get(x_70, 1);
+lean_inc(x_73);
 lean_dec(x_70);
-x_78 = lean_ctor_get(x_69, 1);
-lean_inc(x_78);
-lean_dec(x_69);
-x_79 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_78);
+x_74 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_73);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_7 = x_79;
+x_7 = x_74;
 goto block_16;
 }
-}
 else
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_80 = lean_ctor_get(x_69, 0);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_69, 1);
-lean_inc(x_81);
-if (lean_is_exclusive(x_69)) {
- lean_ctor_release(x_69, 0);
- lean_ctor_release(x_69, 1);
- x_82 = x_69;
+x_75 = lean_ctor_get(x_70, 1);
+lean_inc(x_75);
+if (lean_is_exclusive(x_70)) {
+ lean_ctor_release(x_70, 0);
+ lean_ctor_release(x_70, 1);
+ x_76 = x_70;
 } else {
- lean_dec_ref(x_69);
- x_82 = lean_box(0);
+ lean_dec_ref(x_70);
+ x_76 = lean_box(0);
 }
-if (lean_is_scalar(x_82)) {
- x_83 = lean_alloc_ctor(1, 2, 0);
+x_77 = lean_ctor_get(x_72, 0);
+lean_inc(x_77);
+lean_dec(x_72);
+if (lean_is_scalar(x_76)) {
+ x_78 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_83 = x_82;
+ x_78 = x_76;
 }
-lean_ctor_set(x_83, 0, x_80);
-lean_ctor_set(x_83, 1, x_81);
-x_7 = x_83;
+lean_ctor_set(x_78, 0, x_77);
+lean_ctor_set(x_78, 1, x_75);
+x_7 = x_78;
 goto block_16;
 }
 }
 else
 {
-lean_object* x_84; lean_object* x_85; 
-x_84 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_84, 0, x_57);
-lean_ctor_set_uint8(x_84, 1, x_58);
-lean_ctor_set_uint8(x_84, 2, x_59);
-lean_ctor_set_uint8(x_84, 3, x_60);
-lean_ctor_set_uint8(x_84, 4, x_61);
-lean_ctor_set_uint8(x_84, 5, x_66);
-lean_ctor_set_uint8(x_84, 6, x_63);
-lean_ctor_set_uint8(x_84, 7, x_64);
-lean_ctor_set_uint8(x_84, 8, x_65);
-lean_ctor_set(x_2, 0, x_84);
+lean_object* x_79; lean_object* x_80; 
+lean_dec(x_71);
+x_79 = lean_ctor_get(x_70, 1);
+lean_inc(x_79);
+lean_dec(x_70);
+x_80 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_79);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_7 = x_80;
+goto block_16;
+}
+}
+else
+{
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_81 = lean_ctor_get(x_70, 0);
+lean_inc(x_81);
+x_82 = lean_ctor_get(x_70, 1);
+lean_inc(x_82);
+if (lean_is_exclusive(x_70)) {
+ lean_ctor_release(x_70, 0);
+ lean_ctor_release(x_70, 1);
+ x_83 = x_70;
+} else {
+ lean_dec_ref(x_70);
+ x_83 = lean_box(0);
+}
+if (lean_is_scalar(x_83)) {
+ x_84 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_84 = x_83;
+}
+lean_ctor_set(x_84, 0, x_81);
+lean_ctor_set(x_84, 1, x_82);
+x_7 = x_84;
+goto block_16;
+}
+}
+else
+{
+lean_object* x_85; lean_object* x_86; 
+x_85 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_85, 0, x_57);
+lean_ctor_set_uint8(x_85, 1, x_58);
+lean_ctor_set_uint8(x_85, 2, x_59);
+lean_ctor_set_uint8(x_85, 3, x_60);
+lean_ctor_set_uint8(x_85, 4, x_61);
+lean_ctor_set_uint8(x_85, 5, x_67);
+lean_ctor_set_uint8(x_85, 6, x_63);
+lean_ctor_set_uint8(x_85, 7, x_64);
+lean_ctor_set_uint8(x_85, 8, x_65);
+lean_ctor_set_uint8(x_85, 9, x_66);
+lean_ctor_set(x_2, 0, x_85);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
 lean_inc(x_1);
-x_85 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_85) == 0)
-{
-lean_object* x_86; 
-x_86 = lean_ctor_get(x_85, 0);
-lean_inc(x_86);
-if (lean_obj_tag(x_86) == 9)
+x_86 = l_Lean_Meta_whnf(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_86) == 0)
 {
 lean_object* x_87; 
 x_87 = lean_ctor_get(x_86, 0);
 lean_inc(x_87);
-lean_dec(x_86);
-if (lean_obj_tag(x_87) == 0)
+if (lean_obj_tag(x_87) == 9)
 {
-lean_object* x_88; lean_object* x_89; 
-lean_dec(x_87);
-x_88 = lean_ctor_get(x_85, 1);
+lean_object* x_88; 
+x_88 = lean_ctor_get(x_87, 0);
 lean_inc(x_88);
-lean_dec(x_85);
-x_89 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_88);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_7 = x_89;
-goto block_16;
-}
-else
-{
-lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; 
-lean_dec(x_2);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_90 = lean_ctor_get(x_85, 1);
-lean_inc(x_90);
-if (lean_is_exclusive(x_85)) {
- lean_ctor_release(x_85, 0);
- lean_ctor_release(x_85, 1);
- x_91 = x_85;
-} else {
- lean_dec_ref(x_85);
- x_91 = lean_box(0);
-}
-x_92 = lean_ctor_get(x_87, 0);
-lean_inc(x_92);
 lean_dec(x_87);
-if (lean_is_scalar(x_91)) {
- x_93 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_93 = x_91;
-}
-lean_ctor_set(x_93, 0, x_92);
-lean_ctor_set(x_93, 1, x_90);
-x_7 = x_93;
-goto block_16;
-}
-}
-else
+if (lean_obj_tag(x_88) == 0)
 {
-lean_object* x_94; lean_object* x_95; 
+lean_object* x_89; lean_object* x_90; 
+lean_dec(x_88);
+x_89 = lean_ctor_get(x_86, 1);
+lean_inc(x_89);
 lean_dec(x_86);
-x_94 = lean_ctor_get(x_85, 1);
-lean_inc(x_94);
-lean_dec(x_85);
-x_95 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_94);
+x_90 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_89);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_7 = x_95;
+x_7 = x_90;
 goto block_16;
 }
-}
 else
 {
-lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; 
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_96 = lean_ctor_get(x_85, 0);
-lean_inc(x_96);
-x_97 = lean_ctor_get(x_85, 1);
+x_91 = lean_ctor_get(x_86, 1);
+lean_inc(x_91);
+if (lean_is_exclusive(x_86)) {
+ lean_ctor_release(x_86, 0);
+ lean_ctor_release(x_86, 1);
+ x_92 = x_86;
+} else {
+ lean_dec_ref(x_86);
+ x_92 = lean_box(0);
+}
+x_93 = lean_ctor_get(x_88, 0);
+lean_inc(x_93);
+lean_dec(x_88);
+if (lean_is_scalar(x_92)) {
+ x_94 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_94 = x_92;
+}
+lean_ctor_set(x_94, 0, x_93);
+lean_ctor_set(x_94, 1, x_91);
+x_7 = x_94;
+goto block_16;
+}
+}
+else
+{
+lean_object* x_95; lean_object* x_96; 
+lean_dec(x_87);
+x_95 = lean_ctor_get(x_86, 1);
+lean_inc(x_95);
+lean_dec(x_86);
+x_96 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_2, x_3, x_4, x_5, x_95);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_7 = x_96;
+goto block_16;
+}
+}
+else
+{
+lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_97 = lean_ctor_get(x_86, 0);
 lean_inc(x_97);
-if (lean_is_exclusive(x_85)) {
- lean_ctor_release(x_85, 0);
- lean_ctor_release(x_85, 1);
- x_98 = x_85;
+x_98 = lean_ctor_get(x_86, 1);
+lean_inc(x_98);
+if (lean_is_exclusive(x_86)) {
+ lean_ctor_release(x_86, 0);
+ lean_ctor_release(x_86, 1);
+ x_99 = x_86;
 } else {
- lean_dec_ref(x_85);
- x_98 = lean_box(0);
+ lean_dec_ref(x_86);
+ x_99 = lean_box(0);
 }
-if (lean_is_scalar(x_98)) {
- x_99 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_99)) {
+ x_100 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_99 = x_98;
+ x_100 = x_99;
 }
-lean_ctor_set(x_99, 0, x_96);
-lean_ctor_set(x_99, 1, x_97);
-x_7 = x_99;
+lean_ctor_set(x_100, 0, x_97);
+lean_ctor_set(x_100, 1, x_98);
+x_7 = x_100;
 goto block_16;
 }
 }
@@ -3059,296 +3074,299 @@ goto block_16;
 }
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; uint8_t x_104; uint8_t x_105; uint8_t x_106; uint8_t x_107; uint8_t x_108; uint8_t x_109; uint8_t x_110; uint8_t x_111; uint8_t x_112; lean_object* x_113; uint8_t x_114; uint8_t x_115; 
-x_100 = lean_ctor_get(x_2, 0);
-x_101 = lean_ctor_get(x_2, 1);
-x_102 = lean_ctor_get(x_2, 2);
-x_103 = lean_ctor_get(x_2, 3);
+lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; uint8_t x_105; uint8_t x_106; uint8_t x_107; uint8_t x_108; uint8_t x_109; uint8_t x_110; uint8_t x_111; uint8_t x_112; uint8_t x_113; uint8_t x_114; lean_object* x_115; uint8_t x_116; uint8_t x_117; 
+x_101 = lean_ctor_get(x_2, 0);
+x_102 = lean_ctor_get(x_2, 1);
+x_103 = lean_ctor_get(x_2, 2);
+x_104 = lean_ctor_get(x_2, 3);
+lean_inc(x_104);
 lean_inc(x_103);
 lean_inc(x_102);
 lean_inc(x_101);
-lean_inc(x_100);
 lean_dec(x_2);
-x_104 = lean_ctor_get_uint8(x_100, 0);
-x_105 = lean_ctor_get_uint8(x_100, 1);
-x_106 = lean_ctor_get_uint8(x_100, 2);
-x_107 = lean_ctor_get_uint8(x_100, 3);
-x_108 = lean_ctor_get_uint8(x_100, 4);
-x_109 = lean_ctor_get_uint8(x_100, 5);
-x_110 = lean_ctor_get_uint8(x_100, 6);
-x_111 = lean_ctor_get_uint8(x_100, 7);
-x_112 = lean_ctor_get_uint8(x_100, 8);
-if (lean_is_exclusive(x_100)) {
- x_113 = x_100;
+x_105 = lean_ctor_get_uint8(x_101, 0);
+x_106 = lean_ctor_get_uint8(x_101, 1);
+x_107 = lean_ctor_get_uint8(x_101, 2);
+x_108 = lean_ctor_get_uint8(x_101, 3);
+x_109 = lean_ctor_get_uint8(x_101, 4);
+x_110 = lean_ctor_get_uint8(x_101, 5);
+x_111 = lean_ctor_get_uint8(x_101, 6);
+x_112 = lean_ctor_get_uint8(x_101, 7);
+x_113 = lean_ctor_get_uint8(x_101, 8);
+x_114 = lean_ctor_get_uint8(x_101, 9);
+if (lean_is_exclusive(x_101)) {
+ x_115 = x_101;
 } else {
- lean_dec_ref(x_100);
- x_113 = lean_box(0);
+ lean_dec_ref(x_101);
+ x_115 = lean_box(0);
 }
-x_114 = 1;
-x_115 = l_Lean_Meta_TransparencyMode_lt(x_109, x_114);
-if (x_115 == 0)
+x_116 = 1;
+x_117 = l_Lean_Meta_TransparencyMode_lt(x_110, x_116);
+if (x_117 == 0)
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; 
-if (lean_is_scalar(x_113)) {
- x_116 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_118; lean_object* x_119; lean_object* x_120; 
+if (lean_is_scalar(x_115)) {
+ x_118 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_116 = x_113;
+ x_118 = x_115;
 }
-lean_ctor_set_uint8(x_116, 0, x_104);
-lean_ctor_set_uint8(x_116, 1, x_105);
-lean_ctor_set_uint8(x_116, 2, x_106);
-lean_ctor_set_uint8(x_116, 3, x_107);
-lean_ctor_set_uint8(x_116, 4, x_108);
-lean_ctor_set_uint8(x_116, 5, x_109);
-lean_ctor_set_uint8(x_116, 6, x_110);
-lean_ctor_set_uint8(x_116, 7, x_111);
-lean_ctor_set_uint8(x_116, 8, x_112);
-x_117 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_117, 0, x_116);
-lean_ctor_set(x_117, 1, x_101);
-lean_ctor_set(x_117, 2, x_102);
-lean_ctor_set(x_117, 3, x_103);
+lean_ctor_set_uint8(x_118, 0, x_105);
+lean_ctor_set_uint8(x_118, 1, x_106);
+lean_ctor_set_uint8(x_118, 2, x_107);
+lean_ctor_set_uint8(x_118, 3, x_108);
+lean_ctor_set_uint8(x_118, 4, x_109);
+lean_ctor_set_uint8(x_118, 5, x_110);
+lean_ctor_set_uint8(x_118, 6, x_111);
+lean_ctor_set_uint8(x_118, 7, x_112);
+lean_ctor_set_uint8(x_118, 8, x_113);
+lean_ctor_set_uint8(x_118, 9, x_114);
+x_119 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_119, 0, x_118);
+lean_ctor_set(x_119, 1, x_102);
+lean_ctor_set(x_119, 2, x_103);
+lean_ctor_set(x_119, 3, x_104);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_117);
-lean_inc(x_1);
-x_118 = l_Lean_Meta_whnf(x_1, x_117, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_118) == 0)
-{
-lean_object* x_119; 
-x_119 = lean_ctor_get(x_118, 0);
 lean_inc(x_119);
-if (lean_obj_tag(x_119) == 9)
-{
-lean_object* x_120; 
-x_120 = lean_ctor_get(x_119, 0);
-lean_inc(x_120);
-lean_dec(x_119);
+lean_inc(x_1);
+x_120 = l_Lean_Meta_whnf(x_1, x_119, x_3, x_4, x_5, x_6);
 if (lean_obj_tag(x_120) == 0)
 {
-lean_object* x_121; lean_object* x_122; 
-lean_dec(x_120);
-x_121 = lean_ctor_get(x_118, 1);
+lean_object* x_121; 
+x_121 = lean_ctor_get(x_120, 0);
 lean_inc(x_121);
-lean_dec(x_118);
-x_122 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_117, x_3, x_4, x_5, x_121);
+if (lean_obj_tag(x_121) == 9)
+{
+lean_object* x_122; 
+x_122 = lean_ctor_get(x_121, 0);
+lean_inc(x_122);
+lean_dec(x_121);
+if (lean_obj_tag(x_122) == 0)
+{
+lean_object* x_123; lean_object* x_124; 
+lean_dec(x_122);
+x_123 = lean_ctor_get(x_120, 1);
+lean_inc(x_123);
+lean_dec(x_120);
+x_124 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_119, x_3, x_4, x_5, x_123);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_117);
-x_7 = x_122;
+lean_dec(x_119);
+x_7 = x_124;
 goto block_16;
 }
 else
 {
-lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; 
-lean_dec(x_117);
+lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; 
+lean_dec(x_119);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_123 = lean_ctor_get(x_118, 1);
-lean_inc(x_123);
-if (lean_is_exclusive(x_118)) {
- lean_ctor_release(x_118, 0);
- lean_ctor_release(x_118, 1);
- x_124 = x_118;
-} else {
- lean_dec_ref(x_118);
- x_124 = lean_box(0);
-}
-x_125 = lean_ctor_get(x_120, 0);
+x_125 = lean_ctor_get(x_120, 1);
 lean_inc(x_125);
-lean_dec(x_120);
-if (lean_is_scalar(x_124)) {
- x_126 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_exclusive(x_120)) {
+ lean_ctor_release(x_120, 0);
+ lean_ctor_release(x_120, 1);
+ x_126 = x_120;
 } else {
- x_126 = x_124;
+ lean_dec_ref(x_120);
+ x_126 = lean_box(0);
 }
-lean_ctor_set(x_126, 0, x_125);
-lean_ctor_set(x_126, 1, x_123);
-x_7 = x_126;
-goto block_16;
-}
-}
-else
-{
-lean_object* x_127; lean_object* x_128; 
-lean_dec(x_119);
-x_127 = lean_ctor_get(x_118, 1);
+x_127 = lean_ctor_get(x_122, 0);
 lean_inc(x_127);
-lean_dec(x_118);
-x_128 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_117, x_3, x_4, x_5, x_127);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_117);
+lean_dec(x_122);
+if (lean_is_scalar(x_126)) {
+ x_128 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_128 = x_126;
+}
+lean_ctor_set(x_128, 0, x_127);
+lean_ctor_set(x_128, 1, x_125);
 x_7 = x_128;
 goto block_16;
 }
 }
 else
 {
-lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; 
-lean_dec(x_117);
+lean_object* x_129; lean_object* x_130; 
+lean_dec(x_121);
+x_129 = lean_ctor_get(x_120, 1);
+lean_inc(x_129);
+lean_dec(x_120);
+x_130 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_119, x_3, x_4, x_5, x_129);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_1);
-x_129 = lean_ctor_get(x_118, 0);
-lean_inc(x_129);
-x_130 = lean_ctor_get(x_118, 1);
-lean_inc(x_130);
-if (lean_is_exclusive(x_118)) {
- lean_ctor_release(x_118, 0);
- lean_ctor_release(x_118, 1);
- x_131 = x_118;
-} else {
- lean_dec_ref(x_118);
- x_131 = lean_box(0);
-}
-if (lean_is_scalar(x_131)) {
- x_132 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_132 = x_131;
-}
-lean_ctor_set(x_132, 0, x_129);
-lean_ctor_set(x_132, 1, x_130);
-x_7 = x_132;
+lean_dec(x_119);
+x_7 = x_130;
 goto block_16;
 }
 }
 else
 {
-lean_object* x_133; lean_object* x_134; lean_object* x_135; 
-if (lean_is_scalar(x_113)) {
- x_133 = lean_alloc_ctor(0, 0, 9);
+lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; 
+lean_dec(x_119);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_131 = lean_ctor_get(x_120, 0);
+lean_inc(x_131);
+x_132 = lean_ctor_get(x_120, 1);
+lean_inc(x_132);
+if (lean_is_exclusive(x_120)) {
+ lean_ctor_release(x_120, 0);
+ lean_ctor_release(x_120, 1);
+ x_133 = x_120;
 } else {
- x_133 = x_113;
+ lean_dec_ref(x_120);
+ x_133 = lean_box(0);
 }
-lean_ctor_set_uint8(x_133, 0, x_104);
-lean_ctor_set_uint8(x_133, 1, x_105);
-lean_ctor_set_uint8(x_133, 2, x_106);
-lean_ctor_set_uint8(x_133, 3, x_107);
-lean_ctor_set_uint8(x_133, 4, x_108);
-lean_ctor_set_uint8(x_133, 5, x_114);
-lean_ctor_set_uint8(x_133, 6, x_110);
-lean_ctor_set_uint8(x_133, 7, x_111);
-lean_ctor_set_uint8(x_133, 8, x_112);
-x_134 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_134, 0, x_133);
-lean_ctor_set(x_134, 1, x_101);
-lean_ctor_set(x_134, 2, x_102);
-lean_ctor_set(x_134, 3, x_103);
+if (lean_is_scalar(x_133)) {
+ x_134 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_134 = x_133;
+}
+lean_ctor_set(x_134, 0, x_131);
+lean_ctor_set(x_134, 1, x_132);
+x_7 = x_134;
+goto block_16;
+}
+}
+else
+{
+lean_object* x_135; lean_object* x_136; lean_object* x_137; 
+if (lean_is_scalar(x_115)) {
+ x_135 = lean_alloc_ctor(0, 0, 10);
+} else {
+ x_135 = x_115;
+}
+lean_ctor_set_uint8(x_135, 0, x_105);
+lean_ctor_set_uint8(x_135, 1, x_106);
+lean_ctor_set_uint8(x_135, 2, x_107);
+lean_ctor_set_uint8(x_135, 3, x_108);
+lean_ctor_set_uint8(x_135, 4, x_109);
+lean_ctor_set_uint8(x_135, 5, x_116);
+lean_ctor_set_uint8(x_135, 6, x_111);
+lean_ctor_set_uint8(x_135, 7, x_112);
+lean_ctor_set_uint8(x_135, 8, x_113);
+lean_ctor_set_uint8(x_135, 9, x_114);
+x_136 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_136, 0, x_135);
+lean_ctor_set(x_136, 1, x_102);
+lean_ctor_set(x_136, 2, x_103);
+lean_ctor_set(x_136, 3, x_104);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_134);
-lean_inc(x_1);
-x_135 = l_Lean_Meta_whnf(x_1, x_134, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_135) == 0)
-{
-lean_object* x_136; 
-x_136 = lean_ctor_get(x_135, 0);
 lean_inc(x_136);
-if (lean_obj_tag(x_136) == 9)
-{
-lean_object* x_137; 
-x_137 = lean_ctor_get(x_136, 0);
-lean_inc(x_137);
-lean_dec(x_136);
+lean_inc(x_1);
+x_137 = l_Lean_Meta_whnf(x_1, x_136, x_3, x_4, x_5, x_6);
 if (lean_obj_tag(x_137) == 0)
 {
-lean_object* x_138; lean_object* x_139; 
-lean_dec(x_137);
-x_138 = lean_ctor_get(x_135, 1);
+lean_object* x_138; 
+x_138 = lean_ctor_get(x_137, 0);
 lean_inc(x_138);
-lean_dec(x_135);
-x_139 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_134, x_3, x_4, x_5, x_138);
+if (lean_obj_tag(x_138) == 9)
+{
+lean_object* x_139; 
+x_139 = lean_ctor_get(x_138, 0);
+lean_inc(x_139);
+lean_dec(x_138);
+if (lean_obj_tag(x_139) == 0)
+{
+lean_object* x_140; lean_object* x_141; 
+lean_dec(x_139);
+x_140 = lean_ctor_get(x_137, 1);
+lean_inc(x_140);
+lean_dec(x_137);
+x_141 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_136, x_3, x_4, x_5, x_140);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_134);
-x_7 = x_139;
+lean_dec(x_136);
+x_7 = x_141;
 goto block_16;
 }
 else
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-lean_dec(x_134);
+lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; 
+lean_dec(x_136);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_140 = lean_ctor_get(x_135, 1);
-lean_inc(x_140);
-if (lean_is_exclusive(x_135)) {
- lean_ctor_release(x_135, 0);
- lean_ctor_release(x_135, 1);
- x_141 = x_135;
-} else {
- lean_dec_ref(x_135);
- x_141 = lean_box(0);
-}
-x_142 = lean_ctor_get(x_137, 0);
+x_142 = lean_ctor_get(x_137, 1);
 lean_inc(x_142);
-lean_dec(x_137);
-if (lean_is_scalar(x_141)) {
- x_143 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_exclusive(x_137)) {
+ lean_ctor_release(x_137, 0);
+ lean_ctor_release(x_137, 1);
+ x_143 = x_137;
 } else {
- x_143 = x_141;
+ lean_dec_ref(x_137);
+ x_143 = lean_box(0);
 }
-lean_ctor_set(x_143, 0, x_142);
-lean_ctor_set(x_143, 1, x_140);
-x_7 = x_143;
-goto block_16;
-}
-}
-else
-{
-lean_object* x_144; lean_object* x_145; 
-lean_dec(x_136);
-x_144 = lean_ctor_get(x_135, 1);
+x_144 = lean_ctor_get(x_139, 0);
 lean_inc(x_144);
-lean_dec(x_135);
-x_145 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_134, x_3, x_4, x_5, x_144);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_134);
+lean_dec(x_139);
+if (lean_is_scalar(x_143)) {
+ x_145 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_145 = x_143;
+}
+lean_ctor_set(x_145, 0, x_144);
+lean_ctor_set(x_145, 1, x_142);
 x_7 = x_145;
 goto block_16;
 }
 }
 else
 {
-lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; 
-lean_dec(x_134);
+lean_object* x_146; lean_object* x_147; 
+lean_dec(x_138);
+x_146 = lean_ctor_get(x_137, 1);
+lean_inc(x_146);
+lean_dec(x_137);
+x_147 = l___private_Lean_Meta_ReduceEval_0__Lean_Meta_throwFailedToEval___rarg(x_1, x_136, x_3, x_4, x_5, x_146);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_136);
+x_7 = x_147;
+goto block_16;
+}
+}
+else
+{
+lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
+lean_dec(x_136);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_146 = lean_ctor_get(x_135, 0);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_135, 1);
-lean_inc(x_147);
-if (lean_is_exclusive(x_135)) {
- lean_ctor_release(x_135, 0);
- lean_ctor_release(x_135, 1);
- x_148 = x_135;
+x_148 = lean_ctor_get(x_137, 0);
+lean_inc(x_148);
+x_149 = lean_ctor_get(x_137, 1);
+lean_inc(x_149);
+if (lean_is_exclusive(x_137)) {
+ lean_ctor_release(x_137, 0);
+ lean_ctor_release(x_137, 1);
+ x_150 = x_137;
 } else {
- lean_dec_ref(x_135);
- x_148 = lean_box(0);
+ lean_dec_ref(x_137);
+ x_150 = lean_box(0);
 }
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_150)) {
+ x_151 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_149 = x_148;
+ x_151 = x_150;
 }
-lean_ctor_set(x_149, 0, x_146);
-lean_ctor_set(x_149, 1, x_147);
-x_7 = x_149;
+lean_ctor_set(x_151, 0, x_148);
+lean_ctor_set(x_151, 1, x_149);
+x_7 = x_151;
 goto block_16;
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/SizeOf.c b/stage0/stdlib/Lean/Meta/SizeOf.c
index 0e396969fe..33d6d155e1 100644
--- a/stage0/stdlib/Lean/Meta/SizeOf.c
+++ b/stage0/stdlib/Lean/Meta/SizeOf.c
@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_mkSizeOfSpecLemmaInstance___spec__1___boxed(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 size_t l_USize_add(size_t, size_t);
 lean_object* l_List_tail_x21___rarg(lean_object*);
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
@@ -59,6 +58,7 @@ lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkMinorP
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkMinorProof_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkMinorProof___closed__3;
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfFns___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfo___at___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemmaProof___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -81,7 +81,6 @@ extern lean_object* l_Lean_instInhabitedParserDescr___closed__1;
 lean_object* l_Lean_Meta_SizeOfSpecNested_throwUnexpected(lean_object*);
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkMinorProof___closed__7;
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemmaProof(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_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isApp(lean_object*);
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_isRecField_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SizeOfSpecNested_main_loop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -114,6 +113,7 @@ lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors_loop___rar
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkLocalInstances_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___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*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_whnfI(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Meta_mkSizeOfFns___spec__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_throwKernelException___at_Lean_Meta_mkSizeOfFn___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1836,7 +1836,7 @@ static lean_object* _init_l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMoti
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___closed__2;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -6043,7 +6043,7 @@ x_17 = l_Lean_KernelException_toMessageData___closed__15;
 x_18 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_18, 0, x_16);
 lean_ctor_set(x_18, 1, x_17);
-x_19 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_18, x_2, x_3, x_4, x_5, x_11);
+x_19 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_18, x_2, x_3, x_4, x_5, x_11);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -6204,7 +6204,7 @@ x_68 = l_Lean_KernelException_toMessageData___closed__15;
 x_69 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_69, 0, x_67);
 lean_ctor_set(x_69, 1, x_68);
-x_70 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_69, x_2, x_3, x_4, x_5, x_11);
+x_70 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_69, x_2, x_3, x_4, x_5, x_11);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -6226,7 +6226,7 @@ x_74 = l_Lean_KernelException_toMessageData___closed__15;
 x_75 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_75, 0, x_73);
 lean_ctor_set(x_75, 1, x_74);
-x_76 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_75, x_2, x_3, x_4, x_5, x_6);
+x_76 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_75, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
diff --git a/stage0/stdlib/Lean/Meta/SynthInstance.c b/stage0/stdlib/Lean/Meta/SynthInstance.c
index c746876af5..2a47271d42 100644
--- a/stage0/stdlib/Lean/Meta/SynthInstance.c
+++ b/stage0/stdlib/Lean/Meta/SynthInstance.c
@@ -20,7 +20,6 @@ lean_object* l___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_mkAn
 extern lean_object* l_Lean_instInhabitedTagAttribute___closed__1;
 lean_object* l_Lean_Meta_SynthInstance_getMaxHeartbeats___boxed(lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAux_traverse___at_Lean_Meta_synthInstance_x3f___spec__6(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* lean_expr_update_forall(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_MkTableKey_normExpr_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_instInhabitedAnswer___closed__1;
@@ -77,6 +76,7 @@ lean_object* l_Lean_Meta_SynthInstance_MkTableKey_normLevel___closed__1;
 lean_object* l_Lean_Meta_SynthInstance_tryResolveCore___lambda__1___closed__2;
 lean_object* l_Lean_Meta_SynthInstance_resume___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_getEntry_match__1___rarg(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_Meta_SynthInstance_getResult(lean_object*);
 size_t l_USize_sub(size_t, size_t);
 lean_object* l_Std_HashMapImp_insert___at_Lean_Meta_SynthInstance_MkTableKey_normLevel___spec__3(lean_object*, lean_object*, lean_object*);
@@ -98,7 +98,6 @@ lean_object* l_Lean_Meta_SynthInstance_MkTableKey_normLevel_match__1___rarg(lean
 lean_object* l_Lean_Meta_SynthInstance_newSubgoal___lambda__2(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_object* l_Array_mapMUnsafe_map___at___private_Lean_Util_Trace_0__Lean_addNode___spec__1(size_t, size_t, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_resume_match__1(lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_mkTableKey___closed__1;
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Meta_SynthInstance_findEntry_x3f___spec__2(lean_object*, lean_object*);
@@ -145,6 +144,7 @@ lean_object* l_Lean_Meta_synthInstance___closed__2;
 lean_object* l_Lean_Meta_SynthInstance_getInstances___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_SynthInstance_getInstances___spec__5___closed__1;
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_SynthInstance_getInstances___spec__5___closed__2;
 lean_object* l_Std_HashMapImp_insert___at_Lean_Meta_SynthInstance_newSubgoal___spec__4(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAux_traverse___at_Lean_Meta_synthInstance_x3f___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -309,8 +309,8 @@ size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Meta_SynthInstance_findEntry_x3f___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_4_(lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_28_(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5166_(lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5167_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152_(lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_MkTableKey_State_lmap___default___closed__1;
 lean_object* l_Lean_Meta_SynthInstance_getNextToResume___boxed(lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_MkTableKey_normExpr_match__2(lean_object*);
@@ -379,9 +379,9 @@ lean_object* lean_expr_update_sort(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_wakeUp___closed__1;
 lean_object* l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocess___closed__1;
 lean_object* l_Lean_Meta_SynthInstance_tryResolve___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____closed__1;
 lean_object* l_Lean_Meta_SynthInstance_MkTableKey_normLevel_match__1(lean_object*);
 lean_object* l___private_Lean_Util_Trace_0__Lean_addNode___at_Lean_Meta_SynthInstance_tryResolve___spec__2(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_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____closed__1;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 uint8_t l_USize_decLe(size_t, size_t);
 lean_object* l_Lean_Meta_SynthInstance_getTop___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -543,7 +543,7 @@ lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_o
 lean_object* l_Lean_Meta_SynthInstance_checkMaxHeartbeats___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_inferTCGoalsRLAttr;
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Meta_SynthInstance_MkTableKey_normExpr___spec__2___boxed(lean_object*, lean_object*);
 static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_4____closed__1() {
 _start:
@@ -4119,7 +4119,7 @@ static lean_object* _init_l_Lean_Meta_SynthInstance_getInstances___lambda__1___c
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_4____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -18457,41 +18457,41 @@ return x_2;
 lean_object* l_Lean_Meta_synthInstance_x3f___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_575; lean_object* x_576; lean_object* x_577; 
-x_575 = l_Lean_Meta_synthInstance_maxSize;
-x_576 = l_Lean_Option_get___at_Lean_initFn____x40_Lean_Util_PPExt___hyg_231____spec__1(x_3, x_575);
-x_577 = l_Lean_Meta_getConfig(x_4, x_5, x_6, x_7, x_8);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_577; lean_object* x_578; lean_object* x_579; 
+x_577 = l_Lean_Meta_synthInstance_maxSize;
+x_578 = l_Lean_Option_get___at_Lean_initFn____x40_Lean_Util_PPExt___hyg_231____spec__1(x_3, x_577);
+x_579 = l_Lean_Meta_getConfig(x_4, x_5, x_6, x_7, x_8);
 if (lean_obj_tag(x_2) == 0)
 {
-lean_object* x_578; lean_object* x_579; 
-x_578 = lean_ctor_get(x_577, 0);
-lean_inc(x_578);
-x_579 = lean_ctor_get(x_577, 1);
-lean_inc(x_579);
-lean_dec(x_577);
-x_9 = x_576;
-x_10 = x_578;
-x_11 = x_579;
-goto block_574;
+lean_object* x_580; lean_object* x_581; 
+x_580 = lean_ctor_get(x_579, 0);
+lean_inc(x_580);
+x_581 = lean_ctor_get(x_579, 1);
+lean_inc(x_581);
+lean_dec(x_579);
+x_9 = x_578;
+x_10 = x_580;
+x_11 = x_581;
+goto block_576;
 }
 else
 {
-lean_object* x_580; lean_object* x_581; lean_object* x_582; 
-lean_dec(x_576);
-x_580 = lean_ctor_get(x_2, 0);
-lean_inc(x_580);
-lean_dec(x_2);
-x_581 = lean_ctor_get(x_577, 0);
-lean_inc(x_581);
-x_582 = lean_ctor_get(x_577, 1);
+lean_object* x_582; lean_object* x_583; lean_object* x_584; 
+lean_dec(x_578);
+x_582 = lean_ctor_get(x_2, 0);
 lean_inc(x_582);
-lean_dec(x_577);
-x_9 = x_580;
-x_10 = x_581;
-x_11 = x_582;
-goto block_574;
+lean_dec(x_2);
+x_583 = lean_ctor_get(x_579, 0);
+lean_inc(x_583);
+x_584 = lean_ctor_get(x_579, 1);
+lean_inc(x_584);
+lean_dec(x_579);
+x_9 = x_582;
+x_10 = x_583;
+x_11 = x_584;
+goto block_576;
 }
-block_574:
+block_576:
 {
 uint8_t x_12; 
 x_12 = !lean_is_exclusive(x_4);
@@ -19669,7 +19669,7 @@ return x_274;
 }
 else
 {
-lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; uint8_t x_279; uint8_t x_280; uint8_t x_281; uint8_t x_282; uint8_t x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; 
+lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; uint8_t x_279; uint8_t x_280; uint8_t x_281; uint8_t x_282; uint8_t x_283; uint8_t x_284; uint8_t x_285; lean_object* x_286; lean_object* x_287; 
 x_275 = lean_ctor_get(x_4, 1);
 x_276 = lean_ctor_get(x_4, 2);
 x_277 = lean_ctor_get(x_4, 3);
@@ -19677,579 +19677,581 @@ x_278 = lean_ctor_get_uint8(x_13, 2);
 x_279 = lean_ctor_get_uint8(x_13, 6);
 x_280 = lean_ctor_get_uint8(x_13, 7);
 x_281 = lean_ctor_get_uint8(x_13, 8);
+x_282 = lean_ctor_get_uint8(x_13, 9);
 lean_dec(x_13);
-x_282 = 1;
-x_283 = 0;
-x_284 = 3;
-x_285 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_285, 0, x_282);
-lean_ctor_set_uint8(x_285, 1, x_282);
-lean_ctor_set_uint8(x_285, 2, x_278);
-lean_ctor_set_uint8(x_285, 3, x_283);
-lean_ctor_set_uint8(x_285, 4, x_282);
-lean_ctor_set_uint8(x_285, 5, x_284);
-lean_ctor_set_uint8(x_285, 6, x_279);
-lean_ctor_set_uint8(x_285, 7, x_280);
-lean_ctor_set_uint8(x_285, 8, x_281);
+x_283 = 1;
+x_284 = 0;
+x_285 = 3;
+x_286 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_286, 0, x_283);
+lean_ctor_set_uint8(x_286, 1, x_283);
+lean_ctor_set_uint8(x_286, 2, x_278);
+lean_ctor_set_uint8(x_286, 3, x_284);
+lean_ctor_set_uint8(x_286, 4, x_283);
+lean_ctor_set_uint8(x_286, 5, x_285);
+lean_ctor_set_uint8(x_286, 6, x_279);
+lean_ctor_set_uint8(x_286, 7, x_280);
+lean_ctor_set_uint8(x_286, 8, x_281);
+lean_ctor_set_uint8(x_286, 9, x_282);
 lean_inc(x_277);
 lean_inc(x_276);
 lean_inc(x_275);
-lean_ctor_set(x_4, 0, x_285);
+lean_ctor_set(x_4, 0, x_286);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_286 = l_Lean_Meta_instantiateMVars(x_1, x_4, x_5, x_6, x_7, x_11);
-if (lean_obj_tag(x_286) == 0)
+x_287 = l_Lean_Meta_instantiateMVars(x_1, x_4, x_5, x_6, x_7, x_11);
+if (lean_obj_tag(x_287) == 0)
 {
-lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; 
-x_287 = lean_ctor_get(x_286, 0);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_286, 1);
+lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; 
+x_288 = lean_ctor_get(x_287, 0);
 lean_inc(x_288);
-lean_dec(x_286);
-x_289 = l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocess___closed__1;
+x_289 = lean_ctor_get(x_287, 1);
+lean_inc(x_289);
+lean_dec(x_287);
+x_290 = l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocess___closed__1;
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_290 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_287, x_289, x_4, x_5, x_6, x_7, x_288);
-if (lean_obj_tag(x_290) == 0)
+x_291 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_288, x_290, x_4, x_5, x_6, x_7, x_289);
+if (lean_obj_tag(x_291) == 0)
 {
-lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; 
-x_291 = lean_ctor_get(x_290, 0);
-lean_inc(x_291);
-x_292 = lean_ctor_get(x_290, 1);
+lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; 
+x_292 = lean_ctor_get(x_291, 0);
 lean_inc(x_292);
-lean_dec(x_290);
-x_293 = lean_st_ref_get(x_7, x_292);
-x_294 = lean_ctor_get(x_293, 1);
-lean_inc(x_294);
-lean_dec(x_293);
-x_295 = lean_st_ref_get(x_5, x_294);
-x_296 = lean_ctor_get(x_295, 0);
-lean_inc(x_296);
-x_297 = lean_ctor_get(x_295, 1);
+x_293 = lean_ctor_get(x_291, 1);
+lean_inc(x_293);
+lean_dec(x_291);
+x_294 = lean_st_ref_get(x_7, x_293);
+x_295 = lean_ctor_get(x_294, 1);
+lean_inc(x_295);
+lean_dec(x_294);
+x_296 = lean_st_ref_get(x_5, x_295);
+x_297 = lean_ctor_get(x_296, 0);
 lean_inc(x_297);
-if (lean_is_exclusive(x_295)) {
- lean_ctor_release(x_295, 0);
- lean_ctor_release(x_295, 1);
- x_298 = x_295;
+x_298 = lean_ctor_get(x_296, 1);
+lean_inc(x_298);
+if (lean_is_exclusive(x_296)) {
+ lean_ctor_release(x_296, 0);
+ lean_ctor_release(x_296, 1);
+ x_299 = x_296;
 } else {
- lean_dec_ref(x_295);
- x_298 = lean_box(0);
+ lean_dec_ref(x_296);
+ x_299 = lean_box(0);
 }
-x_299 = lean_ctor_get(x_296, 1);
-lean_inc(x_299);
-lean_dec(x_296);
-x_300 = lean_ctor_get(x_299, 2);
+x_300 = lean_ctor_get(x_297, 1);
 lean_inc(x_300);
-lean_dec(x_299);
-x_301 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_synthInstance_x3f___spec__1(x_300, x_291);
-if (lean_obj_tag(x_301) == 0)
+lean_dec(x_297);
+x_301 = lean_ctor_get(x_300, 2);
+lean_inc(x_301);
+lean_dec(x_300);
+x_302 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_synthInstance_x3f___spec__1(x_301, x_292);
+if (lean_obj_tag(x_302) == 0)
 {
-lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; 
-lean_dec(x_298);
-lean_inc(x_291);
-x_302 = lean_alloc_closure((void*)(l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocessOutParam), 6, 1);
-lean_closure_set(x_302, 0, x_291);
-lean_inc(x_291);
-x_303 = lean_alloc_closure((void*)(l_Lean_Meta_synthInstance_x3f___lambda__2), 8, 2);
-lean_closure_set(x_303, 0, x_9);
-lean_closure_set(x_303, 1, x_291);
-x_304 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Meta_instMonadLCtxMetaM___spec__2___rarg), 7, 2);
-lean_closure_set(x_304, 0, x_302);
-lean_closure_set(x_304, 1, x_303);
+lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; 
+lean_dec(x_299);
+lean_inc(x_292);
+x_303 = lean_alloc_closure((void*)(l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocessOutParam), 6, 1);
+lean_closure_set(x_303, 0, x_292);
+lean_inc(x_292);
+x_304 = lean_alloc_closure((void*)(l_Lean_Meta_synthInstance_x3f___lambda__2), 8, 2);
+lean_closure_set(x_304, 0, x_9);
+lean_closure_set(x_304, 1, x_292);
+x_305 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Meta_instMonadLCtxMetaM___spec__2___rarg), 7, 2);
+lean_closure_set(x_305, 0, x_303);
+lean_closure_set(x_305, 1, x_304);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_305 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_Instances_0__Lean_Meta_mkInstanceKey___spec__1___rarg(x_304, x_4, x_5, x_6, x_7, x_297);
-if (lean_obj_tag(x_305) == 0)
-{
-lean_object* x_306; 
-x_306 = lean_ctor_get(x_305, 0);
-lean_inc(x_306);
+x_306 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_Instances_0__Lean_Meta_mkInstanceKey___spec__1___rarg(x_305, x_4, x_5, x_6, x_7, x_298);
 if (lean_obj_tag(x_306) == 0)
 {
-lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; 
+lean_object* x_307; 
+x_307 = lean_ctor_get(x_306, 0);
+lean_inc(x_307);
+if (lean_obj_tag(x_307) == 0)
+{
+lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; 
 lean_dec(x_277);
 lean_dec(x_276);
 lean_dec(x_275);
 lean_dec(x_10);
-x_307 = lean_ctor_get(x_305, 1);
-lean_inc(x_307);
-lean_dec(x_305);
-x_308 = lean_box(0);
-x_309 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_291, x_308, x_4, x_5, x_6, x_7, x_307);
+x_308 = lean_ctor_get(x_306, 1);
+lean_inc(x_308);
+lean_dec(x_306);
+x_309 = lean_box(0);
+x_310 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_292, x_309, x_4, x_5, x_6, x_7, x_308);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_310 = lean_ctor_get(x_309, 0);
-lean_inc(x_310);
-x_311 = lean_ctor_get(x_309, 1);
+x_311 = lean_ctor_get(x_310, 0);
 lean_inc(x_311);
-if (lean_is_exclusive(x_309)) {
- lean_ctor_release(x_309, 0);
- lean_ctor_release(x_309, 1);
- x_312 = x_309;
+x_312 = lean_ctor_get(x_310, 1);
+lean_inc(x_312);
+if (lean_is_exclusive(x_310)) {
+ lean_ctor_release(x_310, 0);
+ lean_ctor_release(x_310, 1);
+ x_313 = x_310;
 } else {
- lean_dec_ref(x_309);
- x_312 = lean_box(0);
+ lean_dec_ref(x_310);
+ x_313 = lean_box(0);
 }
-if (lean_is_scalar(x_312)) {
- x_313 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_313)) {
+ x_314 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_313 = x_312;
+ x_314 = x_313;
 }
-lean_ctor_set(x_313, 0, x_310);
-lean_ctor_set(x_313, 1, x_311);
-return x_313;
+lean_ctor_set(x_314, 0, x_311);
+lean_ctor_set(x_314, 1, x_312);
+return x_314;
 }
 else
 {
-lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; uint8_t x_387; lean_object* x_388; lean_object* x_398; lean_object* x_399; lean_object* x_400; uint8_t x_401; 
-x_314 = lean_ctor_get(x_305, 1);
-lean_inc(x_314);
-lean_dec(x_305);
-x_315 = lean_ctor_get(x_306, 0);
+lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_388; lean_object* x_389; lean_object* x_399; lean_object* x_400; lean_object* x_401; uint8_t x_402; 
+x_315 = lean_ctor_get(x_306, 1);
 lean_inc(x_315);
+lean_dec(x_306);
+x_316 = lean_ctor_get(x_307, 0);
+lean_inc(x_316);
+if (lean_is_exclusive(x_307)) {
+ lean_ctor_release(x_307, 0);
+ x_317 = x_307;
+} else {
+ lean_dec_ref(x_307);
+ x_317 = lean_box(0);
+}
+x_399 = lean_st_ref_get(x_7, x_315);
+x_400 = lean_ctor_get(x_399, 0);
+lean_inc(x_400);
+x_401 = lean_ctor_get(x_400, 3);
+lean_inc(x_401);
+lean_dec(x_400);
+x_402 = lean_ctor_get_uint8(x_401, sizeof(void*)*1);
+lean_dec(x_401);
+if (x_402 == 0)
+{
+lean_object* x_403; 
+x_403 = lean_ctor_get(x_399, 1);
+lean_inc(x_403);
+lean_dec(x_399);
+x_388 = x_284;
+x_389 = x_403;
+goto block_398;
+}
+else
+{
+lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; 
+x_404 = lean_ctor_get(x_399, 1);
+lean_inc(x_404);
+lean_dec(x_399);
+x_405 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_406 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_405, x_4, x_5, x_6, x_7, x_404);
+x_407 = lean_ctor_get(x_406, 0);
+lean_inc(x_407);
+x_408 = lean_ctor_get(x_406, 1);
+lean_inc(x_408);
+lean_dec(x_406);
+x_409 = lean_unbox(x_407);
+lean_dec(x_407);
+x_388 = x_409;
+x_389 = x_408;
+goto block_398;
+}
+block_387:
+{
+lean_object* x_319; 
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_316);
+x_319 = l_Lean_Meta_inferType(x_316, x_4, x_5, x_6, x_7, x_318);
+if (lean_obj_tag(x_319) == 0)
+{
+lean_object* x_320; lean_object* x_321; uint8_t x_322; lean_object* x_323; lean_object* x_349; lean_object* x_350; 
+x_320 = lean_ctor_get(x_319, 0);
+lean_inc(x_320);
+x_321 = lean_ctor_get(x_319, 1);
+lean_inc(x_321);
+lean_dec(x_319);
+x_349 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_349, 0, x_10);
+lean_ctor_set(x_349, 1, x_275);
+lean_ctor_set(x_349, 2, x_276);
+lean_ctor_set(x_349, 3, x_277);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_320);
+lean_inc(x_292);
+x_350 = l_Lean_Meta_isExprDefEq(x_292, x_320, x_349, x_5, x_6, x_7, x_321);
+if (lean_obj_tag(x_350) == 0)
+{
+lean_object* x_351; uint8_t x_352; 
+x_351 = lean_ctor_get(x_350, 0);
+lean_inc(x_351);
+x_352 = lean_unbox(x_351);
+lean_dec(x_351);
+if (x_352 == 0)
+{
+lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; uint8_t x_357; 
+lean_dec(x_317);
+lean_dec(x_316);
+x_353 = lean_ctor_get(x_350, 1);
+lean_inc(x_353);
+lean_dec(x_350);
+x_354 = lean_st_ref_get(x_7, x_353);
+x_355 = lean_ctor_get(x_354, 0);
+lean_inc(x_355);
+x_356 = lean_ctor_get(x_355, 3);
+lean_inc(x_356);
+lean_dec(x_355);
+x_357 = lean_ctor_get_uint8(x_356, sizeof(void*)*1);
+lean_dec(x_356);
+if (x_357 == 0)
+{
+lean_object* x_358; 
+x_358 = lean_ctor_get(x_354, 1);
+lean_inc(x_358);
+lean_dec(x_354);
+x_322 = x_284;
+x_323 = x_358;
+goto block_348;
+}
+else
+{
+lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; 
+x_359 = lean_ctor_get(x_354, 1);
+lean_inc(x_359);
+lean_dec(x_354);
+x_360 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_361 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_360, x_4, x_5, x_6, x_7, x_359);
+x_362 = lean_ctor_get(x_361, 0);
+lean_inc(x_362);
+x_363 = lean_ctor_get(x_361, 1);
+lean_inc(x_363);
+lean_dec(x_361);
+x_364 = lean_unbox(x_362);
+lean_dec(x_362);
+x_322 = x_364;
+x_323 = x_363;
+goto block_348;
+}
+}
+else
+{
+lean_object* x_365; lean_object* x_366; 
+lean_dec(x_320);
+x_365 = lean_ctor_get(x_350, 1);
+lean_inc(x_365);
+lean_dec(x_350);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+x_366 = l_Lean_Meta_instantiateMVars(x_316, x_4, x_5, x_6, x_7, x_365);
+if (lean_obj_tag(x_366) == 0)
+{
+lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; 
+x_367 = lean_ctor_get(x_366, 0);
+lean_inc(x_367);
+x_368 = lean_ctor_get(x_366, 1);
+lean_inc(x_368);
+lean_dec(x_366);
+if (lean_is_scalar(x_317)) {
+ x_369 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_369 = x_317;
+}
+lean_ctor_set(x_369, 0, x_367);
+x_370 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_292, x_369, x_4, x_5, x_6, x_7, x_368);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_371 = lean_ctor_get(x_370, 0);
+lean_inc(x_371);
+x_372 = lean_ctor_get(x_370, 1);
+lean_inc(x_372);
+if (lean_is_exclusive(x_370)) {
+ lean_ctor_release(x_370, 0);
+ lean_ctor_release(x_370, 1);
+ x_373 = x_370;
+} else {
+ lean_dec_ref(x_370);
+ x_373 = lean_box(0);
+}
+if (lean_is_scalar(x_373)) {
+ x_374 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_374 = x_373;
+}
+lean_ctor_set(x_374, 0, x_371);
+lean_ctor_set(x_374, 1, x_372);
+return x_374;
+}
+else
+{
+lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; 
+lean_dec(x_317);
+lean_dec(x_292);
+lean_dec(x_4);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_375 = lean_ctor_get(x_366, 0);
+lean_inc(x_375);
+x_376 = lean_ctor_get(x_366, 1);
+lean_inc(x_376);
+if (lean_is_exclusive(x_366)) {
+ lean_ctor_release(x_366, 0);
+ lean_ctor_release(x_366, 1);
+ x_377 = x_366;
+} else {
+ lean_dec_ref(x_366);
+ x_377 = lean_box(0);
+}
+if (lean_is_scalar(x_377)) {
+ x_378 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_378 = x_377;
+}
+lean_ctor_set(x_378, 0, x_375);
+lean_ctor_set(x_378, 1, x_376);
+return x_378;
+}
+}
+}
+else
+{
+lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; 
+lean_dec(x_320);
+lean_dec(x_317);
+lean_dec(x_316);
+lean_dec(x_292);
+lean_dec(x_4);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_379 = lean_ctor_get(x_350, 0);
+lean_inc(x_379);
+x_380 = lean_ctor_get(x_350, 1);
+lean_inc(x_380);
+if (lean_is_exclusive(x_350)) {
+ lean_ctor_release(x_350, 0);
+ lean_ctor_release(x_350, 1);
+ x_381 = x_350;
+} else {
+ lean_dec_ref(x_350);
+ x_381 = lean_box(0);
+}
+if (lean_is_scalar(x_381)) {
+ x_382 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_382 = x_381;
+}
+lean_ctor_set(x_382, 0, x_379);
+lean_ctor_set(x_382, 1, x_380);
+return x_382;
+}
+block_348:
+{
+if (x_322 == 0)
+{
+lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; 
+lean_dec(x_320);
+x_324 = lean_box(0);
+x_325 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_292, x_324, x_4, x_5, x_6, x_7, x_323);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_326 = lean_ctor_get(x_325, 0);
+lean_inc(x_326);
+x_327 = lean_ctor_get(x_325, 1);
+lean_inc(x_327);
+if (lean_is_exclusive(x_325)) {
+ lean_ctor_release(x_325, 0);
+ lean_ctor_release(x_325, 1);
+ x_328 = x_325;
+} else {
+ lean_dec_ref(x_325);
+ x_328 = lean_box(0);
+}
+if (lean_is_scalar(x_328)) {
+ x_329 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_329 = x_328;
+}
+lean_ctor_set(x_329, 0, x_326);
+lean_ctor_set(x_329, 1, x_327);
+return x_329;
+}
+else
+{
+lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
+x_330 = l_Lean_indentExpr(x_320);
+x_331 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__2;
+x_332 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_332, 0, x_331);
+lean_ctor_set(x_332, 1, x_330);
+x_333 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__4;
+x_334 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_334, 0, x_332);
+lean_ctor_set(x_334, 1, x_333);
+lean_inc(x_292);
+x_335 = l_Lean_indentExpr(x_292);
+x_336 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_336, 0, x_334);
+lean_ctor_set(x_336, 1, x_335);
+x_337 = l_Lean_KernelException_toMessageData___closed__15;
+x_338 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_338, 0, x_336);
+lean_ctor_set(x_338, 1, x_337);
+x_339 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_340 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_339, x_338, x_4, x_5, x_6, x_7, x_323);
+x_341 = lean_ctor_get(x_340, 1);
+lean_inc(x_341);
+lean_dec(x_340);
+x_342 = lean_box(0);
+x_343 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_292, x_342, x_4, x_5, x_6, x_7, x_341);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_344 = lean_ctor_get(x_343, 0);
+lean_inc(x_344);
+x_345 = lean_ctor_get(x_343, 1);
+lean_inc(x_345);
+if (lean_is_exclusive(x_343)) {
+ lean_ctor_release(x_343, 0);
+ lean_ctor_release(x_343, 1);
+ x_346 = x_343;
+} else {
+ lean_dec_ref(x_343);
+ x_346 = lean_box(0);
+}
+if (lean_is_scalar(x_346)) {
+ x_347 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_347 = x_346;
+}
+lean_ctor_set(x_347, 0, x_344);
+lean_ctor_set(x_347, 1, x_345);
+return x_347;
+}
+}
+}
+else
+{
+lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; 
+lean_dec(x_317);
+lean_dec(x_316);
+lean_dec(x_292);
+lean_dec(x_4);
+lean_dec(x_277);
+lean_dec(x_276);
+lean_dec(x_275);
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_383 = lean_ctor_get(x_319, 0);
+lean_inc(x_383);
+x_384 = lean_ctor_get(x_319, 1);
+lean_inc(x_384);
+if (lean_is_exclusive(x_319)) {
+ lean_ctor_release(x_319, 0);
+ lean_ctor_release(x_319, 1);
+ x_385 = x_319;
+} else {
+ lean_dec_ref(x_319);
+ x_385 = lean_box(0);
+}
+if (lean_is_scalar(x_385)) {
+ x_386 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_386 = x_385;
+}
+lean_ctor_set(x_386, 0, x_383);
+lean_ctor_set(x_386, 1, x_384);
+return x_386;
+}
+}
+block_398:
+{
+if (x_388 == 0)
+{
+x_318 = x_389;
+goto block_387;
+}
+else
+{
+lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; 
+lean_inc(x_316);
+x_390 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_390, 0, x_316);
+x_391 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__6;
+x_392 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_392, 0, x_391);
+lean_ctor_set(x_392, 1, x_390);
+x_393 = l_Lean_KernelException_toMessageData___closed__15;
+x_394 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_394, 0, x_392);
+lean_ctor_set(x_394, 1, x_393);
+x_395 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_396 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_395, x_394, x_4, x_5, x_6, x_7, x_389);
+x_397 = lean_ctor_get(x_396, 1);
+lean_inc(x_397);
+lean_dec(x_396);
+x_318 = x_397;
+goto block_387;
+}
+}
+}
+}
+else
+{
+lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; 
+lean_dec(x_292);
+lean_dec(x_4);
+lean_dec(x_277);
+lean_dec(x_276);
+lean_dec(x_275);
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_410 = lean_ctor_get(x_306, 0);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_306, 1);
+lean_inc(x_411);
 if (lean_is_exclusive(x_306)) {
  lean_ctor_release(x_306, 0);
- x_316 = x_306;
+ lean_ctor_release(x_306, 1);
+ x_412 = x_306;
 } else {
  lean_dec_ref(x_306);
- x_316 = lean_box(0);
+ x_412 = lean_box(0);
 }
-x_398 = lean_st_ref_get(x_7, x_314);
-x_399 = lean_ctor_get(x_398, 0);
-lean_inc(x_399);
-x_400 = lean_ctor_get(x_399, 3);
-lean_inc(x_400);
-lean_dec(x_399);
-x_401 = lean_ctor_get_uint8(x_400, sizeof(void*)*1);
-lean_dec(x_400);
-if (x_401 == 0)
-{
-lean_object* x_402; 
-x_402 = lean_ctor_get(x_398, 1);
-lean_inc(x_402);
-lean_dec(x_398);
-x_387 = x_283;
-x_388 = x_402;
-goto block_397;
+if (lean_is_scalar(x_412)) {
+ x_413 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_413 = x_412;
 }
-else
-{
-lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; uint8_t x_408; 
-x_403 = lean_ctor_get(x_398, 1);
-lean_inc(x_403);
-lean_dec(x_398);
-x_404 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_405 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_404, x_4, x_5, x_6, x_7, x_403);
-x_406 = lean_ctor_get(x_405, 0);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_405, 1);
-lean_inc(x_407);
-lean_dec(x_405);
-x_408 = lean_unbox(x_406);
-lean_dec(x_406);
-x_387 = x_408;
-x_388 = x_407;
-goto block_397;
-}
-block_386:
-{
-lean_object* x_318; 
-lean_inc(x_7);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_315);
-x_318 = l_Lean_Meta_inferType(x_315, x_4, x_5, x_6, x_7, x_317);
-if (lean_obj_tag(x_318) == 0)
-{
-lean_object* x_319; lean_object* x_320; uint8_t x_321; lean_object* x_322; lean_object* x_348; lean_object* x_349; 
-x_319 = lean_ctor_get(x_318, 0);
-lean_inc(x_319);
-x_320 = lean_ctor_get(x_318, 1);
-lean_inc(x_320);
-lean_dec(x_318);
-x_348 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_348, 0, x_10);
-lean_ctor_set(x_348, 1, x_275);
-lean_ctor_set(x_348, 2, x_276);
-lean_ctor_set(x_348, 3, x_277);
-lean_inc(x_7);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_319);
-lean_inc(x_291);
-x_349 = l_Lean_Meta_isExprDefEq(x_291, x_319, x_348, x_5, x_6, x_7, x_320);
-if (lean_obj_tag(x_349) == 0)
-{
-lean_object* x_350; uint8_t x_351; 
-x_350 = lean_ctor_get(x_349, 0);
-lean_inc(x_350);
-x_351 = lean_unbox(x_350);
-lean_dec(x_350);
-if (x_351 == 0)
-{
-lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; uint8_t x_356; 
-lean_dec(x_316);
-lean_dec(x_315);
-x_352 = lean_ctor_get(x_349, 1);
-lean_inc(x_352);
-lean_dec(x_349);
-x_353 = lean_st_ref_get(x_7, x_352);
-x_354 = lean_ctor_get(x_353, 0);
-lean_inc(x_354);
-x_355 = lean_ctor_get(x_354, 3);
-lean_inc(x_355);
-lean_dec(x_354);
-x_356 = lean_ctor_get_uint8(x_355, sizeof(void*)*1);
-lean_dec(x_355);
-if (x_356 == 0)
-{
-lean_object* x_357; 
-x_357 = lean_ctor_get(x_353, 1);
-lean_inc(x_357);
-lean_dec(x_353);
-x_321 = x_283;
-x_322 = x_357;
-goto block_347;
-}
-else
-{
-lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; uint8_t x_363; 
-x_358 = lean_ctor_get(x_353, 1);
-lean_inc(x_358);
-lean_dec(x_353);
-x_359 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_360 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_359, x_4, x_5, x_6, x_7, x_358);
-x_361 = lean_ctor_get(x_360, 0);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_360, 1);
-lean_inc(x_362);
-lean_dec(x_360);
-x_363 = lean_unbox(x_361);
-lean_dec(x_361);
-x_321 = x_363;
-x_322 = x_362;
-goto block_347;
+lean_ctor_set(x_413, 0, x_410);
+lean_ctor_set(x_413, 1, x_411);
+return x_413;
 }
 }
 else
 {
-lean_object* x_364; lean_object* x_365; 
-lean_dec(x_319);
-x_364 = lean_ctor_get(x_349, 1);
-lean_inc(x_364);
-lean_dec(x_349);
-lean_inc(x_7);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
-x_365 = l_Lean_Meta_instantiateMVars(x_315, x_4, x_5, x_6, x_7, x_364);
-if (lean_obj_tag(x_365) == 0)
-{
-lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; 
-x_366 = lean_ctor_get(x_365, 0);
-lean_inc(x_366);
-x_367 = lean_ctor_get(x_365, 1);
-lean_inc(x_367);
-lean_dec(x_365);
-if (lean_is_scalar(x_316)) {
- x_368 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_368 = x_316;
-}
-lean_ctor_set(x_368, 0, x_366);
-x_369 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_291, x_368, x_4, x_5, x_6, x_7, x_367);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-x_370 = lean_ctor_get(x_369, 0);
-lean_inc(x_370);
-x_371 = lean_ctor_get(x_369, 1);
-lean_inc(x_371);
-if (lean_is_exclusive(x_369)) {
- lean_ctor_release(x_369, 0);
- lean_ctor_release(x_369, 1);
- x_372 = x_369;
-} else {
- lean_dec_ref(x_369);
- x_372 = lean_box(0);
-}
-if (lean_is_scalar(x_372)) {
- x_373 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_373 = x_372;
-}
-lean_ctor_set(x_373, 0, x_370);
-lean_ctor_set(x_373, 1, x_371);
-return x_373;
-}
-else
-{
-lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; 
-lean_dec(x_316);
-lean_dec(x_291);
-lean_dec(x_4);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-x_374 = lean_ctor_get(x_365, 0);
-lean_inc(x_374);
-x_375 = lean_ctor_get(x_365, 1);
-lean_inc(x_375);
-if (lean_is_exclusive(x_365)) {
- lean_ctor_release(x_365, 0);
- lean_ctor_release(x_365, 1);
- x_376 = x_365;
-} else {
- lean_dec_ref(x_365);
- x_376 = lean_box(0);
-}
-if (lean_is_scalar(x_376)) {
- x_377 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_377 = x_376;
-}
-lean_ctor_set(x_377, 0, x_374);
-lean_ctor_set(x_377, 1, x_375);
-return x_377;
-}
-}
-}
-else
-{
-lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; 
-lean_dec(x_319);
-lean_dec(x_316);
-lean_dec(x_315);
-lean_dec(x_291);
-lean_dec(x_4);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-x_378 = lean_ctor_get(x_349, 0);
-lean_inc(x_378);
-x_379 = lean_ctor_get(x_349, 1);
-lean_inc(x_379);
-if (lean_is_exclusive(x_349)) {
- lean_ctor_release(x_349, 0);
- lean_ctor_release(x_349, 1);
- x_380 = x_349;
-} else {
- lean_dec_ref(x_349);
- x_380 = lean_box(0);
-}
-if (lean_is_scalar(x_380)) {
- x_381 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_381 = x_380;
-}
-lean_ctor_set(x_381, 0, x_378);
-lean_ctor_set(x_381, 1, x_379);
-return x_381;
-}
-block_347:
-{
-if (x_321 == 0)
-{
-lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; 
-lean_dec(x_319);
-x_323 = lean_box(0);
-x_324 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_291, x_323, x_4, x_5, x_6, x_7, x_322);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-x_325 = lean_ctor_get(x_324, 0);
-lean_inc(x_325);
-x_326 = lean_ctor_get(x_324, 1);
-lean_inc(x_326);
-if (lean_is_exclusive(x_324)) {
- lean_ctor_release(x_324, 0);
- lean_ctor_release(x_324, 1);
- x_327 = x_324;
-} else {
- lean_dec_ref(x_324);
- x_327 = lean_box(0);
-}
-if (lean_is_scalar(x_327)) {
- x_328 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_328 = x_327;
-}
-lean_ctor_set(x_328, 0, x_325);
-lean_ctor_set(x_328, 1, x_326);
-return x_328;
-}
-else
-{
-lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; 
-x_329 = l_Lean_indentExpr(x_319);
-x_330 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__2;
-x_331 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_331, 0, x_330);
-lean_ctor_set(x_331, 1, x_329);
-x_332 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__4;
-x_333 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_333, 0, x_331);
-lean_ctor_set(x_333, 1, x_332);
-lean_inc(x_291);
-x_334 = l_Lean_indentExpr(x_291);
-x_335 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_335, 0, x_333);
-lean_ctor_set(x_335, 1, x_334);
-x_336 = l_Lean_KernelException_toMessageData___closed__15;
-x_337 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_337, 0, x_335);
-lean_ctor_set(x_337, 1, x_336);
-x_338 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_339 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_338, x_337, x_4, x_5, x_6, x_7, x_322);
-x_340 = lean_ctor_get(x_339, 1);
-lean_inc(x_340);
-lean_dec(x_339);
-x_341 = lean_box(0);
-x_342 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_291, x_341, x_4, x_5, x_6, x_7, x_340);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-x_343 = lean_ctor_get(x_342, 0);
-lean_inc(x_343);
-x_344 = lean_ctor_get(x_342, 1);
-lean_inc(x_344);
-if (lean_is_exclusive(x_342)) {
- lean_ctor_release(x_342, 0);
- lean_ctor_release(x_342, 1);
- x_345 = x_342;
-} else {
- lean_dec_ref(x_342);
- x_345 = lean_box(0);
-}
-if (lean_is_scalar(x_345)) {
- x_346 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_346 = x_345;
-}
-lean_ctor_set(x_346, 0, x_343);
-lean_ctor_set(x_346, 1, x_344);
-return x_346;
-}
-}
-}
-else
-{
-lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; 
-lean_dec(x_316);
-lean_dec(x_315);
-lean_dec(x_291);
-lean_dec(x_4);
-lean_dec(x_277);
-lean_dec(x_276);
-lean_dec(x_275);
-lean_dec(x_10);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-x_382 = lean_ctor_get(x_318, 0);
-lean_inc(x_382);
-x_383 = lean_ctor_get(x_318, 1);
-lean_inc(x_383);
-if (lean_is_exclusive(x_318)) {
- lean_ctor_release(x_318, 0);
- lean_ctor_release(x_318, 1);
- x_384 = x_318;
-} else {
- lean_dec_ref(x_318);
- x_384 = lean_box(0);
-}
-if (lean_is_scalar(x_384)) {
- x_385 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_385 = x_384;
-}
-lean_ctor_set(x_385, 0, x_382);
-lean_ctor_set(x_385, 1, x_383);
-return x_385;
-}
-}
-block_397:
-{
-if (x_387 == 0)
-{
-x_317 = x_388;
-goto block_386;
-}
-else
-{
-lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; 
-lean_inc(x_315);
-x_389 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_389, 0, x_315);
-x_390 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__6;
-x_391 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_391, 0, x_390);
-lean_ctor_set(x_391, 1, x_389);
-x_392 = l_Lean_KernelException_toMessageData___closed__15;
-x_393 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_393, 0, x_391);
-lean_ctor_set(x_393, 1, x_392);
-x_394 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_395 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_394, x_393, x_4, x_5, x_6, x_7, x_388);
-x_396 = lean_ctor_get(x_395, 1);
-lean_inc(x_396);
-lean_dec(x_395);
-x_317 = x_396;
-goto block_386;
-}
-}
-}
-}
-else
-{
-lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; 
-lean_dec(x_291);
-lean_dec(x_4);
-lean_dec(x_277);
-lean_dec(x_276);
-lean_dec(x_275);
-lean_dec(x_10);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-x_409 = lean_ctor_get(x_305, 0);
-lean_inc(x_409);
-x_410 = lean_ctor_get(x_305, 1);
-lean_inc(x_410);
-if (lean_is_exclusive(x_305)) {
- lean_ctor_release(x_305, 0);
- lean_ctor_release(x_305, 1);
- x_411 = x_305;
-} else {
- lean_dec_ref(x_305);
- x_411 = lean_box(0);
-}
-if (lean_is_scalar(x_411)) {
- x_412 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_412 = x_411;
-}
-lean_ctor_set(x_412, 0, x_409);
-lean_ctor_set(x_412, 1, x_410);
-return x_412;
-}
-}
-else
-{
-lean_object* x_413; lean_object* x_414; 
-lean_dec(x_291);
+lean_object* x_414; lean_object* x_415; 
+lean_dec(x_292);
 lean_dec(x_4);
 lean_dec(x_277);
 lean_dec(x_276);
@@ -20259,22 +20261,22 @@ lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_413 = lean_ctor_get(x_301, 0);
-lean_inc(x_413);
-lean_dec(x_301);
-if (lean_is_scalar(x_298)) {
- x_414 = lean_alloc_ctor(0, 2, 0);
+x_414 = lean_ctor_get(x_302, 0);
+lean_inc(x_414);
+lean_dec(x_302);
+if (lean_is_scalar(x_299)) {
+ x_415 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_414 = x_298;
+ x_415 = x_299;
 }
-lean_ctor_set(x_414, 0, x_413);
-lean_ctor_set(x_414, 1, x_297);
-return x_414;
+lean_ctor_set(x_415, 0, x_414);
+lean_ctor_set(x_415, 1, x_298);
+return x_415;
 }
 }
 else
 {
-lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; 
+lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; 
 lean_dec(x_4);
 lean_dec(x_277);
 lean_dec(x_276);
@@ -20284,31 +20286,31 @@ lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_415 = lean_ctor_get(x_290, 0);
-lean_inc(x_415);
-x_416 = lean_ctor_get(x_290, 1);
+x_416 = lean_ctor_get(x_291, 0);
 lean_inc(x_416);
-if (lean_is_exclusive(x_290)) {
- lean_ctor_release(x_290, 0);
- lean_ctor_release(x_290, 1);
- x_417 = x_290;
+x_417 = lean_ctor_get(x_291, 1);
+lean_inc(x_417);
+if (lean_is_exclusive(x_291)) {
+ lean_ctor_release(x_291, 0);
+ lean_ctor_release(x_291, 1);
+ x_418 = x_291;
 } else {
- lean_dec_ref(x_290);
- x_417 = lean_box(0);
+ lean_dec_ref(x_291);
+ x_418 = lean_box(0);
 }
-if (lean_is_scalar(x_417)) {
- x_418 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_418)) {
+ x_419 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_418 = x_417;
+ x_419 = x_418;
 }
-lean_ctor_set(x_418, 0, x_415);
-lean_ctor_set(x_418, 1, x_416);
-return x_418;
+lean_ctor_set(x_419, 0, x_416);
+lean_ctor_set(x_419, 1, x_417);
+return x_419;
 }
 }
 else
 {
-lean_object* x_419; lean_object* x_420; lean_object* x_421; lean_object* x_422; 
+lean_object* x_420; lean_object* x_421; lean_object* x_422; lean_object* x_423; 
 lean_dec(x_4);
 lean_dec(x_277);
 lean_dec(x_276);
@@ -20318,719 +20320,721 @@ lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_419 = lean_ctor_get(x_286, 0);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_286, 1);
+x_420 = lean_ctor_get(x_287, 0);
 lean_inc(x_420);
-if (lean_is_exclusive(x_286)) {
- lean_ctor_release(x_286, 0);
- lean_ctor_release(x_286, 1);
- x_421 = x_286;
+x_421 = lean_ctor_get(x_287, 1);
+lean_inc(x_421);
+if (lean_is_exclusive(x_287)) {
+ lean_ctor_release(x_287, 0);
+ lean_ctor_release(x_287, 1);
+ x_422 = x_287;
 } else {
- lean_dec_ref(x_286);
- x_421 = lean_box(0);
+ lean_dec_ref(x_287);
+ x_422 = lean_box(0);
 }
-if (lean_is_scalar(x_421)) {
- x_422 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_422)) {
+ x_423 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_422 = x_421;
+ x_423 = x_422;
 }
-lean_ctor_set(x_422, 0, x_419);
-lean_ctor_set(x_422, 1, x_420);
-return x_422;
+lean_ctor_set(x_423, 0, x_420);
+lean_ctor_set(x_423, 1, x_421);
+return x_423;
 }
 }
 }
 else
 {
-lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; uint8_t x_428; uint8_t x_429; uint8_t x_430; lean_object* x_431; uint8_t x_432; uint8_t x_433; uint8_t x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; 
-x_423 = lean_ctor_get(x_4, 0);
-x_424 = lean_ctor_get(x_4, 1);
-x_425 = lean_ctor_get(x_4, 2);
-x_426 = lean_ctor_get(x_4, 3);
+lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; uint8_t x_428; uint8_t x_429; uint8_t x_430; uint8_t x_431; uint8_t x_432; lean_object* x_433; uint8_t x_434; uint8_t x_435; uint8_t x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; 
+x_424 = lean_ctor_get(x_4, 0);
+x_425 = lean_ctor_get(x_4, 1);
+x_426 = lean_ctor_get(x_4, 2);
+x_427 = lean_ctor_get(x_4, 3);
+lean_inc(x_427);
 lean_inc(x_426);
 lean_inc(x_425);
 lean_inc(x_424);
-lean_inc(x_423);
 lean_dec(x_4);
-x_427 = lean_ctor_get_uint8(x_423, 2);
-x_428 = lean_ctor_get_uint8(x_423, 6);
-x_429 = lean_ctor_get_uint8(x_423, 7);
-x_430 = lean_ctor_get_uint8(x_423, 8);
-if (lean_is_exclusive(x_423)) {
- x_431 = x_423;
+x_428 = lean_ctor_get_uint8(x_424, 2);
+x_429 = lean_ctor_get_uint8(x_424, 6);
+x_430 = lean_ctor_get_uint8(x_424, 7);
+x_431 = lean_ctor_get_uint8(x_424, 8);
+x_432 = lean_ctor_get_uint8(x_424, 9);
+if (lean_is_exclusive(x_424)) {
+ x_433 = x_424;
 } else {
- lean_dec_ref(x_423);
- x_431 = lean_box(0);
+ lean_dec_ref(x_424);
+ x_433 = lean_box(0);
 }
-x_432 = 1;
-x_433 = 0;
-x_434 = 3;
-if (lean_is_scalar(x_431)) {
- x_435 = lean_alloc_ctor(0, 0, 9);
+x_434 = 1;
+x_435 = 0;
+x_436 = 3;
+if (lean_is_scalar(x_433)) {
+ x_437 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_435 = x_431;
+ x_437 = x_433;
 }
-lean_ctor_set_uint8(x_435, 0, x_432);
-lean_ctor_set_uint8(x_435, 1, x_432);
-lean_ctor_set_uint8(x_435, 2, x_427);
-lean_ctor_set_uint8(x_435, 3, x_433);
-lean_ctor_set_uint8(x_435, 4, x_432);
-lean_ctor_set_uint8(x_435, 5, x_434);
-lean_ctor_set_uint8(x_435, 6, x_428);
-lean_ctor_set_uint8(x_435, 7, x_429);
-lean_ctor_set_uint8(x_435, 8, x_430);
+lean_ctor_set_uint8(x_437, 0, x_434);
+lean_ctor_set_uint8(x_437, 1, x_434);
+lean_ctor_set_uint8(x_437, 2, x_428);
+lean_ctor_set_uint8(x_437, 3, x_435);
+lean_ctor_set_uint8(x_437, 4, x_434);
+lean_ctor_set_uint8(x_437, 5, x_436);
+lean_ctor_set_uint8(x_437, 6, x_429);
+lean_ctor_set_uint8(x_437, 7, x_430);
+lean_ctor_set_uint8(x_437, 8, x_431);
+lean_ctor_set_uint8(x_437, 9, x_432);
+lean_inc(x_427);
 lean_inc(x_426);
 lean_inc(x_425);
-lean_inc(x_424);
-x_436 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_436, 0, x_435);
-lean_ctor_set(x_436, 1, x_424);
-lean_ctor_set(x_436, 2, x_425);
-lean_ctor_set(x_436, 3, x_426);
+x_438 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_438, 0, x_437);
+lean_ctor_set(x_438, 1, x_425);
+lean_ctor_set(x_438, 2, x_426);
+lean_ctor_set(x_438, 3, x_427);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_436);
-x_437 = l_Lean_Meta_instantiateMVars(x_1, x_436, x_5, x_6, x_7, x_11);
-if (lean_obj_tag(x_437) == 0)
-{
-lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; 
-x_438 = lean_ctor_get(x_437, 0);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_437, 1);
-lean_inc(x_439);
-lean_dec(x_437);
-x_440 = l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocess___closed__1;
+x_439 = l_Lean_Meta_instantiateMVars(x_1, x_438, x_5, x_6, x_7, x_11);
+if (lean_obj_tag(x_439) == 0)
+{
+lean_object* x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; 
+x_440 = lean_ctor_get(x_439, 0);
+lean_inc(x_440);
+x_441 = lean_ctor_get(x_439, 1);
+lean_inc(x_441);
+lean_dec(x_439);
+x_442 = l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocess___closed__1;
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_436);
-x_441 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_438, x_440, x_436, x_5, x_6, x_7, x_439);
-if (lean_obj_tag(x_441) == 0)
+lean_inc(x_438);
+x_443 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_440, x_442, x_438, x_5, x_6, x_7, x_441);
+if (lean_obj_tag(x_443) == 0)
 {
-lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; 
-x_442 = lean_ctor_get(x_441, 0);
-lean_inc(x_442);
-x_443 = lean_ctor_get(x_441, 1);
-lean_inc(x_443);
-lean_dec(x_441);
-x_444 = lean_st_ref_get(x_7, x_443);
-x_445 = lean_ctor_get(x_444, 1);
+lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; 
+x_444 = lean_ctor_get(x_443, 0);
+lean_inc(x_444);
+x_445 = lean_ctor_get(x_443, 1);
 lean_inc(x_445);
-lean_dec(x_444);
-x_446 = lean_st_ref_get(x_5, x_445);
-x_447 = lean_ctor_get(x_446, 0);
+lean_dec(x_443);
+x_446 = lean_st_ref_get(x_7, x_445);
+x_447 = lean_ctor_get(x_446, 1);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_446, 1);
-lean_inc(x_448);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- x_449 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_449 = lean_box(0);
-}
-x_450 = lean_ctor_get(x_447, 1);
+lean_dec(x_446);
+x_448 = lean_st_ref_get(x_5, x_447);
+x_449 = lean_ctor_get(x_448, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_448, 1);
 lean_inc(x_450);
-lean_dec(x_447);
-x_451 = lean_ctor_get(x_450, 2);
-lean_inc(x_451);
-lean_dec(x_450);
-x_452 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_synthInstance_x3f___spec__1(x_451, x_442);
-if (lean_obj_tag(x_452) == 0)
-{
-lean_object* x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; 
+if (lean_is_exclusive(x_448)) {
+ lean_ctor_release(x_448, 0);
+ lean_ctor_release(x_448, 1);
+ x_451 = x_448;
+} else {
+ lean_dec_ref(x_448);
+ x_451 = lean_box(0);
+}
+x_452 = lean_ctor_get(x_449, 1);
+lean_inc(x_452);
 lean_dec(x_449);
-lean_inc(x_442);
-x_453 = lean_alloc_closure((void*)(l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocessOutParam), 6, 1);
-lean_closure_set(x_453, 0, x_442);
-lean_inc(x_442);
-x_454 = lean_alloc_closure((void*)(l_Lean_Meta_synthInstance_x3f___lambda__2), 8, 2);
-lean_closure_set(x_454, 0, x_9);
-lean_closure_set(x_454, 1, x_442);
-x_455 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Meta_instMonadLCtxMetaM___spec__2___rarg), 7, 2);
-lean_closure_set(x_455, 0, x_453);
-lean_closure_set(x_455, 1, x_454);
+x_453 = lean_ctor_get(x_452, 2);
+lean_inc(x_453);
+lean_dec(x_452);
+x_454 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_synthInstance_x3f___spec__1(x_453, x_444);
+if (lean_obj_tag(x_454) == 0)
+{
+lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; 
+lean_dec(x_451);
+lean_inc(x_444);
+x_455 = lean_alloc_closure((void*)(l___private_Lean_Meta_SynthInstance_0__Lean_Meta_preprocessOutParam), 6, 1);
+lean_closure_set(x_455, 0, x_444);
+lean_inc(x_444);
+x_456 = lean_alloc_closure((void*)(l_Lean_Meta_synthInstance_x3f___lambda__2), 8, 2);
+lean_closure_set(x_456, 0, x_9);
+lean_closure_set(x_456, 1, x_444);
+x_457 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Meta_instMonadLCtxMetaM___spec__2___rarg), 7, 2);
+lean_closure_set(x_457, 0, x_455);
+lean_closure_set(x_457, 1, x_456);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_436);
-x_456 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_Instances_0__Lean_Meta_mkInstanceKey___spec__1___rarg(x_455, x_436, x_5, x_6, x_7, x_448);
-if (lean_obj_tag(x_456) == 0)
+lean_inc(x_438);
+x_458 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_Instances_0__Lean_Meta_mkInstanceKey___spec__1___rarg(x_457, x_438, x_5, x_6, x_7, x_450);
+if (lean_obj_tag(x_458) == 0)
 {
-lean_object* x_457; 
-x_457 = lean_ctor_get(x_456, 0);
-lean_inc(x_457);
-if (lean_obj_tag(x_457) == 0)
+lean_object* x_459; 
+x_459 = lean_ctor_get(x_458, 0);
+lean_inc(x_459);
+if (lean_obj_tag(x_459) == 0)
 {
-lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; 
+lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; 
+lean_dec(x_427);
 lean_dec(x_426);
 lean_dec(x_425);
-lean_dec(x_424);
 lean_dec(x_10);
-x_458 = lean_ctor_get(x_456, 1);
-lean_inc(x_458);
-lean_dec(x_456);
-x_459 = lean_box(0);
-x_460 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_442, x_459, x_436, x_5, x_6, x_7, x_458);
+x_460 = lean_ctor_get(x_458, 1);
+lean_inc(x_460);
+lean_dec(x_458);
+x_461 = lean_box(0);
+x_462 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_444, x_461, x_438, x_5, x_6, x_7, x_460);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-lean_dec(x_436);
-x_461 = lean_ctor_get(x_460, 0);
-lean_inc(x_461);
-x_462 = lean_ctor_get(x_460, 1);
-lean_inc(x_462);
-if (lean_is_exclusive(x_460)) {
- lean_ctor_release(x_460, 0);
- lean_ctor_release(x_460, 1);
- x_463 = x_460;
+lean_dec(x_438);
+x_463 = lean_ctor_get(x_462, 0);
+lean_inc(x_463);
+x_464 = lean_ctor_get(x_462, 1);
+lean_inc(x_464);
+if (lean_is_exclusive(x_462)) {
+ lean_ctor_release(x_462, 0);
+ lean_ctor_release(x_462, 1);
+ x_465 = x_462;
 } else {
- lean_dec_ref(x_460);
- x_463 = lean_box(0);
+ lean_dec_ref(x_462);
+ x_465 = lean_box(0);
 }
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_465)) {
+ x_466 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_464 = x_463;
+ x_466 = x_465;
 }
-lean_ctor_set(x_464, 0, x_461);
-lean_ctor_set(x_464, 1, x_462);
-return x_464;
+lean_ctor_set(x_466, 0, x_463);
+lean_ctor_set(x_466, 1, x_464);
+return x_466;
 }
 else
 {
-lean_object* x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_538; lean_object* x_539; lean_object* x_549; lean_object* x_550; lean_object* x_551; uint8_t x_552; 
-x_465 = lean_ctor_get(x_456, 1);
-lean_inc(x_465);
-lean_dec(x_456);
-x_466 = lean_ctor_get(x_457, 0);
-lean_inc(x_466);
-if (lean_is_exclusive(x_457)) {
- lean_ctor_release(x_457, 0);
- x_467 = x_457;
+lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; uint8_t x_540; lean_object* x_541; lean_object* x_551; lean_object* x_552; lean_object* x_553; uint8_t x_554; 
+x_467 = lean_ctor_get(x_458, 1);
+lean_inc(x_467);
+lean_dec(x_458);
+x_468 = lean_ctor_get(x_459, 0);
+lean_inc(x_468);
+if (lean_is_exclusive(x_459)) {
+ lean_ctor_release(x_459, 0);
+ x_469 = x_459;
 } else {
- lean_dec_ref(x_457);
- x_467 = lean_box(0);
+ lean_dec_ref(x_459);
+ x_469 = lean_box(0);
 }
-x_549 = lean_st_ref_get(x_7, x_465);
-x_550 = lean_ctor_get(x_549, 0);
-lean_inc(x_550);
-x_551 = lean_ctor_get(x_550, 3);
-lean_inc(x_551);
-lean_dec(x_550);
-x_552 = lean_ctor_get_uint8(x_551, sizeof(void*)*1);
-lean_dec(x_551);
-if (x_552 == 0)
-{
-lean_object* x_553; 
-x_553 = lean_ctor_get(x_549, 1);
+x_551 = lean_st_ref_get(x_7, x_467);
+x_552 = lean_ctor_get(x_551, 0);
+lean_inc(x_552);
+x_553 = lean_ctor_get(x_552, 3);
 lean_inc(x_553);
-lean_dec(x_549);
-x_538 = x_433;
-x_539 = x_553;
-goto block_548;
+lean_dec(x_552);
+x_554 = lean_ctor_get_uint8(x_553, sizeof(void*)*1);
+lean_dec(x_553);
+if (x_554 == 0)
+{
+lean_object* x_555; 
+x_555 = lean_ctor_get(x_551, 1);
+lean_inc(x_555);
+lean_dec(x_551);
+x_540 = x_435;
+x_541 = x_555;
+goto block_550;
 }
 else
 {
-lean_object* x_554; lean_object* x_555; lean_object* x_556; lean_object* x_557; lean_object* x_558; uint8_t x_559; 
-x_554 = lean_ctor_get(x_549, 1);
-lean_inc(x_554);
-lean_dec(x_549);
-x_555 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_556 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_555, x_436, x_5, x_6, x_7, x_554);
-x_557 = lean_ctor_get(x_556, 0);
-lean_inc(x_557);
-x_558 = lean_ctor_get(x_556, 1);
-lean_inc(x_558);
-lean_dec(x_556);
-x_559 = lean_unbox(x_557);
-lean_dec(x_557);
-x_538 = x_559;
-x_539 = x_558;
-goto block_548;
+lean_object* x_556; lean_object* x_557; lean_object* x_558; lean_object* x_559; lean_object* x_560; uint8_t x_561; 
+x_556 = lean_ctor_get(x_551, 1);
+lean_inc(x_556);
+lean_dec(x_551);
+x_557 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_558 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_557, x_438, x_5, x_6, x_7, x_556);
+x_559 = lean_ctor_get(x_558, 0);
+lean_inc(x_559);
+x_560 = lean_ctor_get(x_558, 1);
+lean_inc(x_560);
+lean_dec(x_558);
+x_561 = lean_unbox(x_559);
+lean_dec(x_559);
+x_540 = x_561;
+x_541 = x_560;
+goto block_550;
 }
-block_537:
+block_539:
 {
-lean_object* x_469; 
+lean_object* x_471; 
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_436);
-lean_inc(x_466);
-x_469 = l_Lean_Meta_inferType(x_466, x_436, x_5, x_6, x_7, x_468);
-if (lean_obj_tag(x_469) == 0)
+lean_inc(x_438);
+lean_inc(x_468);
+x_471 = l_Lean_Meta_inferType(x_468, x_438, x_5, x_6, x_7, x_470);
+if (lean_obj_tag(x_471) == 0)
 {
-lean_object* x_470; lean_object* x_471; uint8_t x_472; lean_object* x_473; lean_object* x_499; lean_object* x_500; 
-x_470 = lean_ctor_get(x_469, 0);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_469, 1);
-lean_inc(x_471);
-lean_dec(x_469);
-x_499 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_499, 0, x_10);
-lean_ctor_set(x_499, 1, x_424);
-lean_ctor_set(x_499, 2, x_425);
-lean_ctor_set(x_499, 3, x_426);
+lean_object* x_472; lean_object* x_473; uint8_t x_474; lean_object* x_475; lean_object* x_501; lean_object* x_502; 
+x_472 = lean_ctor_get(x_471, 0);
+lean_inc(x_472);
+x_473 = lean_ctor_get(x_471, 1);
+lean_inc(x_473);
+lean_dec(x_471);
+x_501 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_501, 0, x_10);
+lean_ctor_set(x_501, 1, x_425);
+lean_ctor_set(x_501, 2, x_426);
+lean_ctor_set(x_501, 3, x_427);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_470);
-lean_inc(x_442);
-x_500 = l_Lean_Meta_isExprDefEq(x_442, x_470, x_499, x_5, x_6, x_7, x_471);
-if (lean_obj_tag(x_500) == 0)
+lean_inc(x_472);
+lean_inc(x_444);
+x_502 = l_Lean_Meta_isExprDefEq(x_444, x_472, x_501, x_5, x_6, x_7, x_473);
+if (lean_obj_tag(x_502) == 0)
 {
-lean_object* x_501; uint8_t x_502; 
-x_501 = lean_ctor_get(x_500, 0);
-lean_inc(x_501);
-x_502 = lean_unbox(x_501);
-lean_dec(x_501);
-if (x_502 == 0)
-{
-lean_object* x_503; lean_object* x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; 
-lean_dec(x_467);
-lean_dec(x_466);
-x_503 = lean_ctor_get(x_500, 1);
+lean_object* x_503; uint8_t x_504; 
+x_503 = lean_ctor_get(x_502, 0);
 lean_inc(x_503);
-lean_dec(x_500);
-x_504 = lean_st_ref_get(x_7, x_503);
-x_505 = lean_ctor_get(x_504, 0);
+x_504 = lean_unbox(x_503);
+lean_dec(x_503);
+if (x_504 == 0)
+{
+lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; uint8_t x_509; 
+lean_dec(x_469);
+lean_dec(x_468);
+x_505 = lean_ctor_get(x_502, 1);
 lean_inc(x_505);
-x_506 = lean_ctor_get(x_505, 3);
-lean_inc(x_506);
-lean_dec(x_505);
-x_507 = lean_ctor_get_uint8(x_506, sizeof(void*)*1);
-lean_dec(x_506);
-if (x_507 == 0)
-{
-lean_object* x_508; 
-x_508 = lean_ctor_get(x_504, 1);
+lean_dec(x_502);
+x_506 = lean_st_ref_get(x_7, x_505);
+x_507 = lean_ctor_get(x_506, 0);
+lean_inc(x_507);
+x_508 = lean_ctor_get(x_507, 3);
 lean_inc(x_508);
-lean_dec(x_504);
-x_472 = x_433;
-x_473 = x_508;
-goto block_498;
+lean_dec(x_507);
+x_509 = lean_ctor_get_uint8(x_508, sizeof(void*)*1);
+lean_dec(x_508);
+if (x_509 == 0)
+{
+lean_object* x_510; 
+x_510 = lean_ctor_get(x_506, 1);
+lean_inc(x_510);
+lean_dec(x_506);
+x_474 = x_435;
+x_475 = x_510;
+goto block_500;
 }
 else
 {
-lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; uint8_t x_514; 
-x_509 = lean_ctor_get(x_504, 1);
-lean_inc(x_509);
-lean_dec(x_504);
-x_510 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_511 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_510, x_436, x_5, x_6, x_7, x_509);
-x_512 = lean_ctor_get(x_511, 0);
-lean_inc(x_512);
-x_513 = lean_ctor_get(x_511, 1);
-lean_inc(x_513);
-lean_dec(x_511);
-x_514 = lean_unbox(x_512);
-lean_dec(x_512);
-x_472 = x_514;
-x_473 = x_513;
-goto block_498;
-}
-}
-else
-{
-lean_object* x_515; lean_object* x_516; 
-lean_dec(x_470);
-x_515 = lean_ctor_get(x_500, 1);
+lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; uint8_t x_516; 
+x_511 = lean_ctor_get(x_506, 1);
+lean_inc(x_511);
+lean_dec(x_506);
+x_512 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_513 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_512, x_438, x_5, x_6, x_7, x_511);
+x_514 = lean_ctor_get(x_513, 0);
+lean_inc(x_514);
+x_515 = lean_ctor_get(x_513, 1);
 lean_inc(x_515);
-lean_dec(x_500);
+lean_dec(x_513);
+x_516 = lean_unbox(x_514);
+lean_dec(x_514);
+x_474 = x_516;
+x_475 = x_515;
+goto block_500;
+}
+}
+else
+{
+lean_object* x_517; lean_object* x_518; 
+lean_dec(x_472);
+x_517 = lean_ctor_get(x_502, 1);
+lean_inc(x_517);
+lean_dec(x_502);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_436);
-x_516 = l_Lean_Meta_instantiateMVars(x_466, x_436, x_5, x_6, x_7, x_515);
-if (lean_obj_tag(x_516) == 0)
+lean_inc(x_438);
+x_518 = l_Lean_Meta_instantiateMVars(x_468, x_438, x_5, x_6, x_7, x_517);
+if (lean_obj_tag(x_518) == 0)
 {
-lean_object* x_517; lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; 
-x_517 = lean_ctor_get(x_516, 0);
-lean_inc(x_517);
-x_518 = lean_ctor_get(x_516, 1);
-lean_inc(x_518);
-lean_dec(x_516);
-if (lean_is_scalar(x_467)) {
- x_519 = lean_alloc_ctor(1, 1, 0);
+lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; lean_object* x_526; 
+x_519 = lean_ctor_get(x_518, 0);
+lean_inc(x_519);
+x_520 = lean_ctor_get(x_518, 1);
+lean_inc(x_520);
+lean_dec(x_518);
+if (lean_is_scalar(x_469)) {
+ x_521 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_519 = x_467;
+ x_521 = x_469;
 }
-lean_ctor_set(x_519, 0, x_517);
-x_520 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_442, x_519, x_436, x_5, x_6, x_7, x_518);
+lean_ctor_set(x_521, 0, x_519);
+x_522 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_444, x_521, x_438, x_5, x_6, x_7, x_520);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-lean_dec(x_436);
-x_521 = lean_ctor_get(x_520, 0);
-lean_inc(x_521);
-x_522 = lean_ctor_get(x_520, 1);
-lean_inc(x_522);
-if (lean_is_exclusive(x_520)) {
- lean_ctor_release(x_520, 0);
- lean_ctor_release(x_520, 1);
- x_523 = x_520;
+lean_dec(x_438);
+x_523 = lean_ctor_get(x_522, 0);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_522, 1);
+lean_inc(x_524);
+if (lean_is_exclusive(x_522)) {
+ lean_ctor_release(x_522, 0);
+ lean_ctor_release(x_522, 1);
+ x_525 = x_522;
 } else {
- lean_dec_ref(x_520);
- x_523 = lean_box(0);
+ lean_dec_ref(x_522);
+ x_525 = lean_box(0);
 }
-if (lean_is_scalar(x_523)) {
- x_524 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_525)) {
+ x_526 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_524 = x_523;
+ x_526 = x_525;
 }
-lean_ctor_set(x_524, 0, x_521);
-lean_ctor_set(x_524, 1, x_522);
-return x_524;
+lean_ctor_set(x_526, 0, x_523);
+lean_ctor_set(x_526, 1, x_524);
+return x_526;
 }
 else
 {
-lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; 
-lean_dec(x_467);
-lean_dec(x_442);
-lean_dec(x_436);
+lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; 
+lean_dec(x_469);
+lean_dec(x_444);
+lean_dec(x_438);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_525 = lean_ctor_get(x_516, 0);
-lean_inc(x_525);
-x_526 = lean_ctor_get(x_516, 1);
-lean_inc(x_526);
-if (lean_is_exclusive(x_516)) {
- lean_ctor_release(x_516, 0);
- lean_ctor_release(x_516, 1);
- x_527 = x_516;
+x_527 = lean_ctor_get(x_518, 0);
+lean_inc(x_527);
+x_528 = lean_ctor_get(x_518, 1);
+lean_inc(x_528);
+if (lean_is_exclusive(x_518)) {
+ lean_ctor_release(x_518, 0);
+ lean_ctor_release(x_518, 1);
+ x_529 = x_518;
 } else {
- lean_dec_ref(x_516);
- x_527 = lean_box(0);
+ lean_dec_ref(x_518);
+ x_529 = lean_box(0);
 }
-if (lean_is_scalar(x_527)) {
- x_528 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_529)) {
+ x_530 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_528 = x_527;
+ x_530 = x_529;
 }
-lean_ctor_set(x_528, 0, x_525);
-lean_ctor_set(x_528, 1, x_526);
-return x_528;
+lean_ctor_set(x_530, 0, x_527);
+lean_ctor_set(x_530, 1, x_528);
+return x_530;
 }
 }
 }
 else
 {
-lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; 
-lean_dec(x_470);
-lean_dec(x_467);
-lean_dec(x_466);
-lean_dec(x_442);
-lean_dec(x_436);
+lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; 
+lean_dec(x_472);
+lean_dec(x_469);
+lean_dec(x_468);
+lean_dec(x_444);
+lean_dec(x_438);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_529 = lean_ctor_get(x_500, 0);
-lean_inc(x_529);
-x_530 = lean_ctor_get(x_500, 1);
-lean_inc(x_530);
-if (lean_is_exclusive(x_500)) {
- lean_ctor_release(x_500, 0);
- lean_ctor_release(x_500, 1);
- x_531 = x_500;
+x_531 = lean_ctor_get(x_502, 0);
+lean_inc(x_531);
+x_532 = lean_ctor_get(x_502, 1);
+lean_inc(x_532);
+if (lean_is_exclusive(x_502)) {
+ lean_ctor_release(x_502, 0);
+ lean_ctor_release(x_502, 1);
+ x_533 = x_502;
 } else {
- lean_dec_ref(x_500);
- x_531 = lean_box(0);
+ lean_dec_ref(x_502);
+ x_533 = lean_box(0);
 }
-if (lean_is_scalar(x_531)) {
- x_532 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_533)) {
+ x_534 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_532 = x_531;
+ x_534 = x_533;
 }
-lean_ctor_set(x_532, 0, x_529);
-lean_ctor_set(x_532, 1, x_530);
-return x_532;
+lean_ctor_set(x_534, 0, x_531);
+lean_ctor_set(x_534, 1, x_532);
+return x_534;
 }
-block_498:
+block_500:
 {
-if (x_472 == 0)
+if (x_474 == 0)
 {
-lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; 
-lean_dec(x_470);
-x_474 = lean_box(0);
-x_475 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_442, x_474, x_436, x_5, x_6, x_7, x_473);
+lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; 
+lean_dec(x_472);
+x_476 = lean_box(0);
+x_477 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_444, x_476, x_438, x_5, x_6, x_7, x_475);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-lean_dec(x_436);
-x_476 = lean_ctor_get(x_475, 0);
-lean_inc(x_476);
-x_477 = lean_ctor_get(x_475, 1);
-lean_inc(x_477);
-if (lean_is_exclusive(x_475)) {
- lean_ctor_release(x_475, 0);
- lean_ctor_release(x_475, 1);
- x_478 = x_475;
+lean_dec(x_438);
+x_478 = lean_ctor_get(x_477, 0);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_477, 1);
+lean_inc(x_479);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ x_480 = x_477;
 } else {
- lean_dec_ref(x_475);
- x_478 = lean_box(0);
+ lean_dec_ref(x_477);
+ x_480 = lean_box(0);
 }
-if (lean_is_scalar(x_478)) {
- x_479 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_480)) {
+ x_481 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_479 = x_478;
+ x_481 = x_480;
 }
-lean_ctor_set(x_479, 0, x_476);
-lean_ctor_set(x_479, 1, x_477);
-return x_479;
+lean_ctor_set(x_481, 0, x_478);
+lean_ctor_set(x_481, 1, x_479);
+return x_481;
 }
 else
 {
-lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; lean_object* x_495; lean_object* x_496; lean_object* x_497; 
-x_480 = l_Lean_indentExpr(x_470);
-x_481 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__2;
-x_482 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_482, 0, x_481);
-lean_ctor_set(x_482, 1, x_480);
-x_483 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__4;
+lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; 
+x_482 = l_Lean_indentExpr(x_472);
+x_483 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__2;
 x_484 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_484, 0, x_482);
-lean_ctor_set(x_484, 1, x_483);
-lean_inc(x_442);
-x_485 = l_Lean_indentExpr(x_442);
+lean_ctor_set(x_484, 0, x_483);
+lean_ctor_set(x_484, 1, x_482);
+x_485 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__4;
 x_486 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_486, 0, x_484);
 lean_ctor_set(x_486, 1, x_485);
-x_487 = l_Lean_KernelException_toMessageData___closed__15;
+lean_inc(x_444);
+x_487 = l_Lean_indentExpr(x_444);
 x_488 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_488, 0, x_486);
 lean_ctor_set(x_488, 1, x_487);
-x_489 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_490 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_489, x_488, x_436, x_5, x_6, x_7, x_473);
-x_491 = lean_ctor_get(x_490, 1);
-lean_inc(x_491);
-lean_dec(x_490);
-x_492 = lean_box(0);
-x_493 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_442, x_492, x_436, x_5, x_6, x_7, x_491);
+x_489 = l_Lean_KernelException_toMessageData___closed__15;
+x_490 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_490, 0, x_488);
+lean_ctor_set(x_490, 1, x_489);
+x_491 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_492 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_491, x_490, x_438, x_5, x_6, x_7, x_475);
+x_493 = lean_ctor_get(x_492, 1);
+lean_inc(x_493);
+lean_dec(x_492);
+x_494 = lean_box(0);
+x_495 = l_Lean_Meta_synthInstance_x3f___lambda__3(x_444, x_494, x_438, x_5, x_6, x_7, x_493);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-lean_dec(x_436);
-x_494 = lean_ctor_get(x_493, 0);
-lean_inc(x_494);
-x_495 = lean_ctor_get(x_493, 1);
-lean_inc(x_495);
-if (lean_is_exclusive(x_493)) {
- lean_ctor_release(x_493, 0);
- lean_ctor_release(x_493, 1);
- x_496 = x_493;
+lean_dec(x_438);
+x_496 = lean_ctor_get(x_495, 0);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_495, 1);
+lean_inc(x_497);
+if (lean_is_exclusive(x_495)) {
+ lean_ctor_release(x_495, 0);
+ lean_ctor_release(x_495, 1);
+ x_498 = x_495;
 } else {
- lean_dec_ref(x_493);
- x_496 = lean_box(0);
+ lean_dec_ref(x_495);
+ x_498 = lean_box(0);
 }
-if (lean_is_scalar(x_496)) {
- x_497 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_498)) {
+ x_499 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_497 = x_496;
+ x_499 = x_498;
 }
-lean_ctor_set(x_497, 0, x_494);
-lean_ctor_set(x_497, 1, x_495);
-return x_497;
+lean_ctor_set(x_499, 0, x_496);
+lean_ctor_set(x_499, 1, x_497);
+return x_499;
 }
 }
 }
 else
 {
-lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; 
-lean_dec(x_467);
-lean_dec(x_466);
-lean_dec(x_442);
-lean_dec(x_436);
+lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; 
+lean_dec(x_469);
+lean_dec(x_468);
+lean_dec(x_444);
+lean_dec(x_438);
+lean_dec(x_427);
 lean_dec(x_426);
 lean_dec(x_425);
-lean_dec(x_424);
 lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_533 = lean_ctor_get(x_469, 0);
-lean_inc(x_533);
-x_534 = lean_ctor_get(x_469, 1);
-lean_inc(x_534);
-if (lean_is_exclusive(x_469)) {
- lean_ctor_release(x_469, 0);
- lean_ctor_release(x_469, 1);
- x_535 = x_469;
+x_535 = lean_ctor_get(x_471, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_471, 1);
+lean_inc(x_536);
+if (lean_is_exclusive(x_471)) {
+ lean_ctor_release(x_471, 0);
+ lean_ctor_release(x_471, 1);
+ x_537 = x_471;
 } else {
- lean_dec_ref(x_469);
- x_535 = lean_box(0);
+ lean_dec_ref(x_471);
+ x_537 = lean_box(0);
 }
-if (lean_is_scalar(x_535)) {
- x_536 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_537)) {
+ x_538 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_536 = x_535;
+ x_538 = x_537;
 }
-lean_ctor_set(x_536, 0, x_533);
-lean_ctor_set(x_536, 1, x_534);
-return x_536;
+lean_ctor_set(x_538, 0, x_535);
+lean_ctor_set(x_538, 1, x_536);
+return x_538;
 }
 }
-block_548:
+block_550:
 {
-if (x_538 == 0)
+if (x_540 == 0)
 {
-x_468 = x_539;
-goto block_537;
+x_470 = x_541;
+goto block_539;
 }
 else
 {
-lean_object* x_540; lean_object* x_541; lean_object* x_542; lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; 
-lean_inc(x_466);
-x_540 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_540, 0, x_466);
-x_541 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__6;
-x_542 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_542, 0, x_541);
-lean_ctor_set(x_542, 1, x_540);
-x_543 = l_Lean_KernelException_toMessageData___closed__15;
+lean_object* x_542; lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; 
+lean_inc(x_468);
+x_542 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_542, 0, x_468);
+x_543 = l_Lean_Meta_synthInstance_x3f___lambda__4___closed__6;
 x_544 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_544, 0, x_542);
-lean_ctor_set(x_544, 1, x_543);
-x_545 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
-x_546 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_545, x_544, x_436, x_5, x_6, x_7, x_539);
-x_547 = lean_ctor_get(x_546, 1);
-lean_inc(x_547);
-lean_dec(x_546);
-x_468 = x_547;
-goto block_537;
+lean_ctor_set(x_544, 0, x_543);
+lean_ctor_set(x_544, 1, x_542);
+x_545 = l_Lean_KernelException_toMessageData___closed__15;
+x_546 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_546, 0, x_544);
+lean_ctor_set(x_546, 1, x_545);
+x_547 = l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__3;
+x_548 = l_Lean_addTrace___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__1(x_547, x_546, x_438, x_5, x_6, x_7, x_541);
+x_549 = lean_ctor_get(x_548, 1);
+lean_inc(x_549);
+lean_dec(x_548);
+x_470 = x_549;
+goto block_539;
 }
 }
 }
 }
 else
 {
-lean_object* x_560; lean_object* x_561; lean_object* x_562; lean_object* x_563; 
-lean_dec(x_442);
-lean_dec(x_436);
+lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; 
+lean_dec(x_444);
+lean_dec(x_438);
+lean_dec(x_427);
 lean_dec(x_426);
 lean_dec(x_425);
-lean_dec(x_424);
 lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_560 = lean_ctor_get(x_456, 0);
-lean_inc(x_560);
-x_561 = lean_ctor_get(x_456, 1);
-lean_inc(x_561);
-if (lean_is_exclusive(x_456)) {
- lean_ctor_release(x_456, 0);
- lean_ctor_release(x_456, 1);
- x_562 = x_456;
+x_562 = lean_ctor_get(x_458, 0);
+lean_inc(x_562);
+x_563 = lean_ctor_get(x_458, 1);
+lean_inc(x_563);
+if (lean_is_exclusive(x_458)) {
+ lean_ctor_release(x_458, 0);
+ lean_ctor_release(x_458, 1);
+ x_564 = x_458;
 } else {
- lean_dec_ref(x_456);
- x_562 = lean_box(0);
+ lean_dec_ref(x_458);
+ x_564 = lean_box(0);
 }
-if (lean_is_scalar(x_562)) {
- x_563 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_564)) {
+ x_565 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_563 = x_562;
+ x_565 = x_564;
 }
-lean_ctor_set(x_563, 0, x_560);
-lean_ctor_set(x_563, 1, x_561);
-return x_563;
-}
-}
-else
-{
-lean_object* x_564; lean_object* x_565; 
-lean_dec(x_442);
-lean_dec(x_436);
-lean_dec(x_426);
-lean_dec(x_425);
-lean_dec(x_424);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-x_564 = lean_ctor_get(x_452, 0);
-lean_inc(x_564);
-lean_dec(x_452);
-if (lean_is_scalar(x_449)) {
- x_565 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_565 = x_449;
-}
-lean_ctor_set(x_565, 0, x_564);
-lean_ctor_set(x_565, 1, x_448);
+lean_ctor_set(x_565, 0, x_562);
+lean_ctor_set(x_565, 1, x_563);
 return x_565;
 }
 }
 else
 {
-lean_object* x_566; lean_object* x_567; lean_object* x_568; lean_object* x_569; 
-lean_dec(x_436);
+lean_object* x_566; lean_object* x_567; 
+lean_dec(x_444);
+lean_dec(x_438);
+lean_dec(x_427);
 lean_dec(x_426);
 lean_dec(x_425);
-lean_dec(x_424);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_566 = lean_ctor_get(x_441, 0);
+x_566 = lean_ctor_get(x_454, 0);
 lean_inc(x_566);
-x_567 = lean_ctor_get(x_441, 1);
-lean_inc(x_567);
-if (lean_is_exclusive(x_441)) {
- lean_ctor_release(x_441, 0);
- lean_ctor_release(x_441, 1);
- x_568 = x_441;
+lean_dec(x_454);
+if (lean_is_scalar(x_451)) {
+ x_567 = lean_alloc_ctor(0, 2, 0);
 } else {
- lean_dec_ref(x_441);
- x_568 = lean_box(0);
+ x_567 = x_451;
 }
-if (lean_is_scalar(x_568)) {
- x_569 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_569 = x_568;
-}
-lean_ctor_set(x_569, 0, x_566);
-lean_ctor_set(x_569, 1, x_567);
-return x_569;
+lean_ctor_set(x_567, 0, x_566);
+lean_ctor_set(x_567, 1, x_450);
+return x_567;
 }
 }
 else
 {
-lean_object* x_570; lean_object* x_571; lean_object* x_572; lean_object* x_573; 
-lean_dec(x_436);
+lean_object* x_568; lean_object* x_569; lean_object* x_570; lean_object* x_571; 
+lean_dec(x_438);
+lean_dec(x_427);
 lean_dec(x_426);
 lean_dec(x_425);
-lean_dec(x_424);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_570 = lean_ctor_get(x_437, 0);
-lean_inc(x_570);
-x_571 = lean_ctor_get(x_437, 1);
-lean_inc(x_571);
-if (lean_is_exclusive(x_437)) {
- lean_ctor_release(x_437, 0);
- lean_ctor_release(x_437, 1);
- x_572 = x_437;
+x_568 = lean_ctor_get(x_443, 0);
+lean_inc(x_568);
+x_569 = lean_ctor_get(x_443, 1);
+lean_inc(x_569);
+if (lean_is_exclusive(x_443)) {
+ lean_ctor_release(x_443, 0);
+ lean_ctor_release(x_443, 1);
+ x_570 = x_443;
 } else {
- lean_dec_ref(x_437);
- x_572 = lean_box(0);
+ lean_dec_ref(x_443);
+ x_570 = lean_box(0);
 }
-if (lean_is_scalar(x_572)) {
- x_573 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_570)) {
+ x_571 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_573 = x_572;
+ x_571 = x_570;
 }
-lean_ctor_set(x_573, 0, x_570);
-lean_ctor_set(x_573, 1, x_571);
-return x_573;
+lean_ctor_set(x_571, 0, x_568);
+lean_ctor_set(x_571, 1, x_569);
+return x_571;
+}
+}
+else
+{
+lean_object* x_572; lean_object* x_573; lean_object* x_574; lean_object* x_575; 
+lean_dec(x_438);
+lean_dec(x_427);
+lean_dec(x_426);
+lean_dec(x_425);
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_572 = lean_ctor_get(x_439, 0);
+lean_inc(x_572);
+x_573 = lean_ctor_get(x_439, 1);
+lean_inc(x_573);
+if (lean_is_exclusive(x_439)) {
+ lean_ctor_release(x_439, 0);
+ lean_ctor_release(x_439, 1);
+ x_574 = x_439;
+} else {
+ lean_dec_ref(x_439);
+ x_574 = lean_box(0);
+}
+if (lean_is_scalar(x_574)) {
+ x_575 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_575 = x_574;
+}
+lean_ctor_set(x_575, 0, x_572);
+lean_ctor_set(x_575, 1, x_573);
+return x_575;
 }
 }
 }
@@ -21341,7 +21345,7 @@ x_28 = l_Lean_KernelException_toMessageData___closed__15;
 x_29 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_29, 0, x_27);
 lean_ctor_set(x_29, 1, x_28);
-x_30 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_29, x_3, x_4, x_5, x_6, x_24);
+x_30 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_29, x_3, x_4, x_5, x_6, x_24);
 x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
 x_32 = lean_ctor_get(x_30, 1);
@@ -21448,7 +21452,7 @@ x_18 = l_Lean_KernelException_toMessageData___closed__15;
 x_19 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_19, 0, x_17);
 lean_ctor_set(x_19, 1, x_18);
-x_20 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_19, x_3, x_4, x_5, x_6, x_9);
+x_20 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_19, x_3, x_4, x_5, x_6, x_9);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
@@ -22181,7 +22185,7 @@ return x_135;
 }
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; 
@@ -22190,20 +22194,20 @@ x_8 = l___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp(x_1, x_7,
 return x_8;
 }
 }
-static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____closed__1() {
+static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____lambda__1), 6, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____lambda__1), 6, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; uint8_t x_5; 
 x_2 = l_Lean_Meta_synthPendingRef;
-x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____closed__1;
+x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____closed__1;
 x_4 = lean_st_ref_set(x_2, x_3, x_1);
 x_5 = !lean_is_exclusive(x_4);
 if (x_5 == 0)
@@ -22225,7 +22229,7 @@ return x_8;
 }
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5166_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5167_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -22667,12 +22671,12 @@ l_Lean_Meta_synthInstance___closed__1 = _init_l_Lean_Meta_synthInstance___closed
 lean_mark_persistent(l_Lean_Meta_synthInstance___closed__1);
 l_Lean_Meta_synthInstance___closed__2 = _init_l_Lean_Meta_synthInstance___closed__2();
 lean_mark_persistent(l_Lean_Meta_synthInstance___closed__2);
-l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____closed__1();
-lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151____closed__1);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5151_(lean_io_mk_world());
+l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____closed__1();
+lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152____closed__1);
+res = l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5152_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5166_(lean_io_mk_world());
+res = l_Lean_Meta_initFn____x40_Lean_Meta_SynthInstance___hyg_5167_(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));
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Apply.c b/stage0/stdlib/Lean/Meta/Tactic/Apply.c
index d1e7334bc4..2fe0091ad0 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Apply.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Apply.c
@@ -233,7 +233,7 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
 x_21 = lean_ctor_get_uint8(x_8, 0);
 x_22 = lean_ctor_get_uint8(x_8, 1);
 x_23 = lean_ctor_get_uint8(x_8, 2);
@@ -242,166 +242,170 @@ x_25 = lean_ctor_get_uint8(x_8, 4);
 x_26 = lean_ctor_get_uint8(x_8, 6);
 x_27 = lean_ctor_get_uint8(x_8, 7);
 x_28 = lean_ctor_get_uint8(x_8, 8);
+x_29 = lean_ctor_get_uint8(x_8, 9);
 lean_dec(x_8);
-x_29 = 1;
-x_30 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_30, 0, x_21);
-lean_ctor_set_uint8(x_30, 1, x_22);
-lean_ctor_set_uint8(x_30, 2, x_23);
-lean_ctor_set_uint8(x_30, 3, x_24);
-lean_ctor_set_uint8(x_30, 4, x_25);
-lean_ctor_set_uint8(x_30, 5, x_29);
-lean_ctor_set_uint8(x_30, 6, x_26);
-lean_ctor_set_uint8(x_30, 7, x_27);
-lean_ctor_set_uint8(x_30, 8, x_28);
-lean_ctor_set(x_2, 0, x_30);
-x_31 = l_Lean_Meta_getExpectedNumArgsAux___closed__1;
-x_32 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_1, x_31, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_32) == 0)
+x_30 = 1;
+x_31 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_31, 0, x_21);
+lean_ctor_set_uint8(x_31, 1, x_22);
+lean_ctor_set_uint8(x_31, 2, x_23);
+lean_ctor_set_uint8(x_31, 3, x_24);
+lean_ctor_set_uint8(x_31, 4, x_25);
+lean_ctor_set_uint8(x_31, 5, x_30);
+lean_ctor_set_uint8(x_31, 6, x_26);
+lean_ctor_set_uint8(x_31, 7, x_27);
+lean_ctor_set_uint8(x_31, 8, x_28);
+lean_ctor_set_uint8(x_31, 9, x_29);
+lean_ctor_set(x_2, 0, x_31);
+x_32 = l_Lean_Meta_getExpectedNumArgsAux___closed__1;
+x_33 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_1, x_32, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_33 = lean_ctor_get(x_32, 0);
-lean_inc(x_33);
-x_34 = lean_ctor_get(x_32, 1);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_34 = lean_ctor_get(x_33, 0);
 lean_inc(x_34);
-if (lean_is_exclusive(x_32)) {
- lean_ctor_release(x_32, 0);
- lean_ctor_release(x_32, 1);
- x_35 = x_32;
+x_35 = lean_ctor_get(x_33, 1);
+lean_inc(x_35);
+if (lean_is_exclusive(x_33)) {
+ lean_ctor_release(x_33, 0);
+ lean_ctor_release(x_33, 1);
+ x_36 = x_33;
 } else {
- lean_dec_ref(x_32);
- x_35 = lean_box(0);
+ lean_dec_ref(x_33);
+ x_36 = lean_box(0);
 }
-if (lean_is_scalar(x_35)) {
- x_36 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_36)) {
+ x_37 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_36 = x_35;
+ x_37 = x_36;
 }
-lean_ctor_set(x_36, 0, x_33);
-lean_ctor_set(x_36, 1, x_34);
-return x_36;
+lean_ctor_set(x_37, 0, x_34);
+lean_ctor_set(x_37, 1, x_35);
+return x_37;
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-x_37 = lean_ctor_get(x_32, 0);
-lean_inc(x_37);
-x_38 = lean_ctor_get(x_32, 1);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_38 = lean_ctor_get(x_33, 0);
 lean_inc(x_38);
-if (lean_is_exclusive(x_32)) {
- lean_ctor_release(x_32, 0);
- lean_ctor_release(x_32, 1);
- x_39 = x_32;
+x_39 = lean_ctor_get(x_33, 1);
+lean_inc(x_39);
+if (lean_is_exclusive(x_33)) {
+ lean_ctor_release(x_33, 0);
+ lean_ctor_release(x_33, 1);
+ x_40 = x_33;
 } else {
- lean_dec_ref(x_32);
- x_39 = lean_box(0);
+ lean_dec_ref(x_33);
+ x_40 = lean_box(0);
 }
-if (lean_is_scalar(x_39)) {
- x_40 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_40)) {
+ x_41 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_40 = x_39;
+ x_41 = x_40;
 }
-lean_ctor_set(x_40, 0, x_37);
-lean_ctor_set(x_40, 1, x_38);
-return x_40;
+lean_ctor_set(x_41, 0, x_38);
+lean_ctor_set(x_41, 1, x_39);
+return x_41;
 }
 }
 }
 else
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-x_41 = lean_ctor_get(x_2, 0);
-x_42 = lean_ctor_get(x_2, 1);
-x_43 = lean_ctor_get(x_2, 2);
-x_44 = lean_ctor_get(x_2, 3);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_42 = lean_ctor_get(x_2, 0);
+x_43 = lean_ctor_get(x_2, 1);
+x_44 = lean_ctor_get(x_2, 2);
+x_45 = lean_ctor_get(x_2, 3);
+lean_inc(x_45);
 lean_inc(x_44);
 lean_inc(x_43);
 lean_inc(x_42);
-lean_inc(x_41);
 lean_dec(x_2);
-x_45 = lean_ctor_get_uint8(x_41, 0);
-x_46 = lean_ctor_get_uint8(x_41, 1);
-x_47 = lean_ctor_get_uint8(x_41, 2);
-x_48 = lean_ctor_get_uint8(x_41, 3);
-x_49 = lean_ctor_get_uint8(x_41, 4);
-x_50 = lean_ctor_get_uint8(x_41, 6);
-x_51 = lean_ctor_get_uint8(x_41, 7);
-x_52 = lean_ctor_get_uint8(x_41, 8);
-if (lean_is_exclusive(x_41)) {
- x_53 = x_41;
+x_46 = lean_ctor_get_uint8(x_42, 0);
+x_47 = lean_ctor_get_uint8(x_42, 1);
+x_48 = lean_ctor_get_uint8(x_42, 2);
+x_49 = lean_ctor_get_uint8(x_42, 3);
+x_50 = lean_ctor_get_uint8(x_42, 4);
+x_51 = lean_ctor_get_uint8(x_42, 6);
+x_52 = lean_ctor_get_uint8(x_42, 7);
+x_53 = lean_ctor_get_uint8(x_42, 8);
+x_54 = lean_ctor_get_uint8(x_42, 9);
+if (lean_is_exclusive(x_42)) {
+ x_55 = x_42;
 } else {
- lean_dec_ref(x_41);
- x_53 = lean_box(0);
+ lean_dec_ref(x_42);
+ x_55 = lean_box(0);
 }
-x_54 = 1;
-if (lean_is_scalar(x_53)) {
- x_55 = lean_alloc_ctor(0, 0, 9);
+x_56 = 1;
+if (lean_is_scalar(x_55)) {
+ x_57 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_55 = x_53;
+ x_57 = x_55;
 }
-lean_ctor_set_uint8(x_55, 0, x_45);
-lean_ctor_set_uint8(x_55, 1, x_46);
-lean_ctor_set_uint8(x_55, 2, x_47);
-lean_ctor_set_uint8(x_55, 3, x_48);
-lean_ctor_set_uint8(x_55, 4, x_49);
-lean_ctor_set_uint8(x_55, 5, x_54);
-lean_ctor_set_uint8(x_55, 6, x_50);
-lean_ctor_set_uint8(x_55, 7, x_51);
-lean_ctor_set_uint8(x_55, 8, x_52);
-x_56 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_56, 0, x_55);
-lean_ctor_set(x_56, 1, x_42);
-lean_ctor_set(x_56, 2, x_43);
-lean_ctor_set(x_56, 3, x_44);
-x_57 = l_Lean_Meta_getExpectedNumArgsAux___closed__1;
-x_58 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_1, x_57, x_56, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_58) == 0)
+lean_ctor_set_uint8(x_57, 0, x_46);
+lean_ctor_set_uint8(x_57, 1, x_47);
+lean_ctor_set_uint8(x_57, 2, x_48);
+lean_ctor_set_uint8(x_57, 3, x_49);
+lean_ctor_set_uint8(x_57, 4, x_50);
+lean_ctor_set_uint8(x_57, 5, x_56);
+lean_ctor_set_uint8(x_57, 6, x_51);
+lean_ctor_set_uint8(x_57, 7, x_52);
+lean_ctor_set_uint8(x_57, 8, x_53);
+lean_ctor_set_uint8(x_57, 9, x_54);
+x_58 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_58, 0, x_57);
+lean_ctor_set(x_58, 1, x_43);
+lean_ctor_set(x_58, 2, x_44);
+lean_ctor_set(x_58, 3, x_45);
+x_59 = l_Lean_Meta_getExpectedNumArgsAux___closed__1;
+x_60 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_1, x_59, x_58, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_60) == 0)
 {
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_58, 1);
-lean_inc(x_60);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_61 = x_58;
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_61 = lean_ctor_get(x_60, 0);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_60, 1);
+lean_inc(x_62);
+if (lean_is_exclusive(x_60)) {
+ lean_ctor_release(x_60, 0);
+ lean_ctor_release(x_60, 1);
+ x_63 = x_60;
 } else {
- lean_dec_ref(x_58);
- x_61 = lean_box(0);
+ lean_dec_ref(x_60);
+ x_63 = lean_box(0);
 }
-if (lean_is_scalar(x_61)) {
- x_62 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_63)) {
+ x_64 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_62 = x_61;
+ x_64 = x_63;
 }
-lean_ctor_set(x_62, 0, x_59);
-lean_ctor_set(x_62, 1, x_60);
-return x_62;
+lean_ctor_set(x_64, 0, x_61);
+lean_ctor_set(x_64, 1, x_62);
+return x_64;
 }
 else
 {
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-x_63 = lean_ctor_get(x_58, 0);
-lean_inc(x_63);
-x_64 = lean_ctor_get(x_58, 1);
-lean_inc(x_64);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_65 = x_58;
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+x_65 = lean_ctor_get(x_60, 0);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_60, 1);
+lean_inc(x_66);
+if (lean_is_exclusive(x_60)) {
+ lean_ctor_release(x_60, 0);
+ lean_ctor_release(x_60, 1);
+ x_67 = x_60;
 } else {
- lean_dec_ref(x_58);
- x_65 = lean_box(0);
+ lean_dec_ref(x_60);
+ x_67 = lean_box(0);
 }
-if (lean_is_scalar(x_65)) {
- x_66 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_67)) {
+ x_68 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_66 = x_65;
+ x_68 = x_67;
 }
-lean_ctor_set(x_66, 0, x_63);
-lean_ctor_set(x_66, 1, x_64);
-return x_66;
+lean_ctor_set(x_68, 0, x_65);
+lean_ctor_set(x_68, 1, x_66);
+return x_68;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Contradiction.c b/stage0/stdlib/Lean/Meta/Tactic/Contradiction.c
index 329d1c981d..044410da60 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Contradiction.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Contradiction.c
@@ -2452,7 +2452,7 @@ return x_118;
 }
 else
 {
-uint8_t x_119; uint8_t x_120; uint8_t x_121; uint8_t x_122; uint8_t x_123; uint8_t x_124; uint8_t x_125; uint8_t x_126; uint8_t x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; 
+uint8_t x_119; uint8_t x_120; uint8_t x_121; uint8_t x_122; uint8_t x_123; uint8_t x_124; uint8_t x_125; uint8_t x_126; uint8_t x_127; uint8_t x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; 
 x_119 = lean_ctor_get_uint8(x_27, 0);
 x_120 = lean_ctor_get_uint8(x_27, 1);
 x_121 = lean_ctor_get_uint8(x_27, 2);
@@ -2461,285 +2461,287 @@ x_123 = lean_ctor_get_uint8(x_27, 4);
 x_124 = lean_ctor_get_uint8(x_27, 6);
 x_125 = lean_ctor_get_uint8(x_27, 7);
 x_126 = lean_ctor_get_uint8(x_27, 8);
+x_127 = lean_ctor_get_uint8(x_27, 9);
 lean_dec(x_27);
-x_127 = 1;
-x_128 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_128, 0, x_119);
-lean_ctor_set_uint8(x_128, 1, x_120);
-lean_ctor_set_uint8(x_128, 2, x_121);
-lean_ctor_set_uint8(x_128, 3, x_122);
-lean_ctor_set_uint8(x_128, 4, x_123);
-lean_ctor_set_uint8(x_128, 5, x_127);
-lean_ctor_set_uint8(x_128, 6, x_124);
-lean_ctor_set_uint8(x_128, 7, x_125);
-lean_ctor_set_uint8(x_128, 8, x_126);
-x_129 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_129, 0, x_128);
-lean_ctor_set(x_129, 1, x_30);
-lean_ctor_set(x_129, 2, x_31);
-lean_ctor_set(x_129, 3, x_32);
+x_128 = 1;
+x_129 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_129, 0, x_119);
+lean_ctor_set_uint8(x_129, 1, x_120);
+lean_ctor_set_uint8(x_129, 2, x_121);
+lean_ctor_set_uint8(x_129, 3, x_122);
+lean_ctor_set_uint8(x_129, 4, x_123);
+lean_ctor_set_uint8(x_129, 5, x_128);
+lean_ctor_set_uint8(x_129, 6, x_124);
+lean_ctor_set_uint8(x_129, 7, x_125);
+lean_ctor_set_uint8(x_129, 8, x_126);
+lean_ctor_set_uint8(x_129, 9, x_127);
+x_130 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_130, 0, x_129);
+lean_ctor_set(x_130, 1, x_30);
+lean_ctor_set(x_130, 2, x_31);
+lean_ctor_set(x_130, 3, x_32);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_28);
-x_130 = l_Lean_Meta_whnf(x_28, x_129, x_8, x_9, x_10, x_29);
-if (lean_obj_tag(x_130) == 0)
+x_131 = l_Lean_Meta_whnf(x_28, x_130, x_8, x_9, x_10, x_29);
+if (lean_obj_tag(x_131) == 0)
 {
-lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; uint8_t x_135; 
-x_131 = lean_ctor_get(x_130, 0);
-lean_inc(x_131);
-x_132 = lean_ctor_get(x_130, 1);
+lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; 
+x_132 = lean_ctor_get(x_131, 0);
 lean_inc(x_132);
-if (lean_is_exclusive(x_130)) {
- lean_ctor_release(x_130, 0);
- lean_ctor_release(x_130, 1);
- x_133 = x_130;
+x_133 = lean_ctor_get(x_131, 1);
+lean_inc(x_133);
+if (lean_is_exclusive(x_131)) {
+ lean_ctor_release(x_131, 0);
+ lean_ctor_release(x_131, 1);
+ x_134 = x_131;
 } else {
- lean_dec_ref(x_130);
- x_133 = lean_box(0);
+ lean_dec_ref(x_131);
+ x_134 = lean_box(0);
 }
-x_134 = l_Lean_instQuoteBool___closed__3;
-x_135 = l_Lean_Expr_isConstOf(x_131, x_134);
-lean_dec(x_131);
-if (x_135 == 0)
+x_135 = l_Lean_instQuoteBool___closed__3;
+x_136 = l_Lean_Expr_isConstOf(x_132, x_135);
+lean_dec(x_132);
+if (x_136 == 0)
 {
-lean_object* x_136; lean_object* x_137; 
+lean_object* x_137; lean_object* x_138; 
 lean_dec(x_28);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
-x_136 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_136, 0, x_2);
-if (lean_is_scalar(x_133)) {
- x_137 = lean_alloc_ctor(0, 2, 0);
+x_137 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_137, 0, x_2);
+if (lean_is_scalar(x_134)) {
+ x_138 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_137 = x_133;
+ x_138 = x_134;
 }
-lean_ctor_set(x_137, 0, x_136);
-lean_ctor_set(x_137, 1, x_132);
-return x_137;
+lean_ctor_set(x_138, 0, x_137);
+lean_ctor_set(x_138, 1, x_133);
+return x_138;
 }
 else
 {
-lean_object* x_138; 
-lean_dec(x_133);
+lean_object* x_139; 
+lean_dec(x_134);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_28);
-x_138 = l_Lean_Meta_mkEqRefl(x_28, x_7, x_8, x_9, x_10, x_132);
-if (lean_obj_tag(x_138) == 0)
+x_139 = l_Lean_Meta_mkEqRefl(x_28, x_7, x_8, x_9, x_10, x_133);
+if (lean_obj_tag(x_139) == 0)
 {
-lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
-x_139 = lean_ctor_get(x_138, 0);
-lean_inc(x_139);
-x_140 = lean_ctor_get(x_138, 1);
+lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
+x_140 = lean_ctor_get(x_139, 0);
 lean_inc(x_140);
-lean_dec(x_138);
-x_141 = lean_unsigned_to_nat(0u);
-x_142 = l_Lean_Expr_getAppNumArgsAux(x_28, x_141);
-x_143 = l_Lean_Expr_getAppArgs___closed__1;
-lean_inc(x_142);
-x_144 = lean_mk_array(x_142, x_143);
-x_145 = lean_unsigned_to_nat(1u);
-x_146 = lean_nat_sub(x_142, x_145);
-lean_dec(x_142);
-x_147 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_28, x_144, x_146);
-x_148 = lean_array_push(x_147, x_139);
-x_149 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__3;
-x_150 = l_Lean_mkAppN(x_149, x_148);
-lean_dec(x_148);
+x_141 = lean_ctor_get(x_139, 1);
+lean_inc(x_141);
+lean_dec(x_139);
+x_142 = lean_unsigned_to_nat(0u);
+x_143 = l_Lean_Expr_getAppNumArgsAux(x_28, x_142);
+x_144 = l_Lean_Expr_getAppArgs___closed__1;
+lean_inc(x_143);
+x_145 = lean_mk_array(x_143, x_144);
+x_146 = lean_unsigned_to_nat(1u);
+x_147 = lean_nat_sub(x_143, x_146);
+lean_dec(x_143);
+x_148 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_28, x_145, x_147);
+x_149 = lean_array_push(x_148, x_140);
+x_150 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__3;
+x_151 = l_Lean_mkAppN(x_150, x_149);
+lean_dec(x_149);
 lean_inc(x_4);
-x_151 = l_Lean_Meta_getMVarType(x_4, x_7, x_8, x_9, x_10, x_140);
-if (lean_obj_tag(x_151) == 0)
+x_152 = l_Lean_Meta_getMVarType(x_4, x_7, x_8, x_9, x_10, x_141);
+if (lean_obj_tag(x_152) == 0)
 {
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; 
-x_152 = lean_ctor_get(x_151, 0);
-lean_inc(x_152);
-x_153 = lean_ctor_get(x_151, 1);
+lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; 
+x_153 = lean_ctor_get(x_152, 0);
 lean_inc(x_153);
-lean_dec(x_151);
-x_154 = l_Lean_LocalDecl_toExpr(x_5);
+x_154 = lean_ctor_get(x_152, 1);
+lean_inc(x_154);
+lean_dec(x_152);
+x_155 = l_Lean_LocalDecl_toExpr(x_5);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
-x_155 = l_Lean_Meta_mkAbsurd(x_152, x_154, x_150, x_7, x_8, x_9, x_10, x_153);
-if (lean_obj_tag(x_155) == 0)
+x_156 = l_Lean_Meta_mkAbsurd(x_153, x_155, x_151, x_7, x_8, x_9, x_10, x_154);
+if (lean_obj_tag(x_156) == 0)
 {
-lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; 
-x_156 = lean_ctor_get(x_155, 0);
-lean_inc(x_156);
-x_157 = lean_ctor_get(x_155, 1);
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; 
+x_157 = lean_ctor_get(x_156, 0);
 lean_inc(x_157);
-lean_dec(x_155);
-x_158 = l_Lean_Meta_assignExprMVar(x_4, x_156, x_7, x_8, x_9, x_10, x_157);
+x_158 = lean_ctor_get(x_156, 1);
+lean_inc(x_158);
+lean_dec(x_156);
+x_159 = l_Lean_Meta_assignExprMVar(x_4, x_157, x_7, x_8, x_9, x_10, x_158);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
-x_159 = lean_ctor_get(x_158, 1);
-lean_inc(x_159);
-lean_dec(x_158);
-x_160 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__4;
-x_12 = x_160;
-x_13 = x_159;
+x_160 = lean_ctor_get(x_159, 1);
+lean_inc(x_160);
+lean_dec(x_159);
+x_161 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__4;
+x_12 = x_161;
+x_13 = x_160;
 goto block_22;
 }
 else
 {
-lean_object* x_161; lean_object* x_162; 
+lean_object* x_162; lean_object* x_163; 
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
-x_161 = lean_ctor_get(x_155, 1);
-lean_inc(x_161);
-lean_dec(x_155);
-x_162 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__5;
-x_12 = x_162;
-x_13 = x_161;
+x_162 = lean_ctor_get(x_156, 1);
+lean_inc(x_162);
+lean_dec(x_156);
+x_163 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__5;
+x_12 = x_163;
+x_13 = x_162;
 goto block_22;
 }
 }
 else
 {
-lean_object* x_163; lean_object* x_164; 
-lean_dec(x_150);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-x_163 = lean_ctor_get(x_151, 1);
-lean_inc(x_163);
+lean_object* x_164; lean_object* x_165; 
 lean_dec(x_151);
-x_164 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__5;
-x_12 = x_164;
-x_13 = x_163;
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_4);
+x_164 = lean_ctor_get(x_152, 1);
+lean_inc(x_164);
+lean_dec(x_152);
+x_165 = l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__1___closed__5;
+x_12 = x_165;
+x_13 = x_164;
 goto block_22;
 }
 }
 else
 {
-lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; 
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; 
 lean_dec(x_28);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
-x_165 = lean_ctor_get(x_138, 1);
-lean_inc(x_165);
-if (lean_is_exclusive(x_138)) {
- lean_ctor_release(x_138, 0);
- lean_ctor_release(x_138, 1);
- x_166 = x_138;
+x_166 = lean_ctor_get(x_139, 1);
+lean_inc(x_166);
+if (lean_is_exclusive(x_139)) {
+ lean_ctor_release(x_139, 0);
+ lean_ctor_release(x_139, 1);
+ x_167 = x_139;
 } else {
- lean_dec_ref(x_138);
- x_166 = lean_box(0);
+ lean_dec_ref(x_139);
+ x_167 = lean_box(0);
 }
-x_167 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_167, 0, x_2);
-if (lean_is_scalar(x_166)) {
- x_168 = lean_alloc_ctor(0, 2, 0);
+x_168 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_168, 0, x_2);
+if (lean_is_scalar(x_167)) {
+ x_169 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_168 = x_166;
- lean_ctor_set_tag(x_168, 0);
+ x_169 = x_167;
+ lean_ctor_set_tag(x_169, 0);
 }
-lean_ctor_set(x_168, 0, x_167);
-lean_ctor_set(x_168, 1, x_165);
-return x_168;
+lean_ctor_set(x_169, 0, x_168);
+lean_ctor_set(x_169, 1, x_166);
+return x_169;
 }
 }
 }
 else
 {
-lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; 
+lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; 
 lean_dec(x_28);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
-x_169 = lean_ctor_get(x_130, 1);
-lean_inc(x_169);
-if (lean_is_exclusive(x_130)) {
- lean_ctor_release(x_130, 0);
- lean_ctor_release(x_130, 1);
- x_170 = x_130;
+x_170 = lean_ctor_get(x_131, 1);
+lean_inc(x_170);
+if (lean_is_exclusive(x_131)) {
+ lean_ctor_release(x_131, 0);
+ lean_ctor_release(x_131, 1);
+ x_171 = x_131;
 } else {
- lean_dec_ref(x_130);
- x_170 = lean_box(0);
+ lean_dec_ref(x_131);
+ x_171 = lean_box(0);
 }
-x_171 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_171, 0, x_2);
-if (lean_is_scalar(x_170)) {
- x_172 = lean_alloc_ctor(0, 2, 0);
+x_172 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_172, 0, x_2);
+if (lean_is_scalar(x_171)) {
+ x_173 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_172 = x_170;
- lean_ctor_set_tag(x_172, 0);
+ x_173 = x_171;
+ lean_ctor_set_tag(x_173, 0);
 }
-lean_ctor_set(x_172, 0, x_171);
-lean_ctor_set(x_172, 1, x_169);
-return x_172;
+lean_ctor_set(x_173, 0, x_172);
+lean_ctor_set(x_173, 1, x_170);
+return x_173;
 }
 }
 }
 else
 {
-uint8_t x_173; 
+uint8_t x_174; 
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
-x_173 = !lean_is_exclusive(x_26);
-if (x_173 == 0)
+x_174 = !lean_is_exclusive(x_26);
+if (x_174 == 0)
 {
-lean_object* x_174; lean_object* x_175; 
-x_174 = lean_ctor_get(x_26, 0);
-lean_dec(x_174);
-x_175 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_175, 0, x_2);
+lean_object* x_175; lean_object* x_176; 
+x_175 = lean_ctor_get(x_26, 0);
+lean_dec(x_175);
+x_176 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_176, 0, x_2);
 lean_ctor_set_tag(x_26, 0);
-lean_ctor_set(x_26, 0, x_175);
+lean_ctor_set(x_26, 0, x_176);
 return x_26;
 }
 else
 {
-lean_object* x_176; lean_object* x_177; lean_object* x_178; 
-x_176 = lean_ctor_get(x_26, 1);
-lean_inc(x_176);
+lean_object* x_177; lean_object* x_178; lean_object* x_179; 
+x_177 = lean_ctor_get(x_26, 1);
+lean_inc(x_177);
 lean_dec(x_26);
-x_177 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_177, 0, x_2);
-x_178 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set(x_178, 1, x_176);
-return x_178;
+x_178 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_178, 0, x_2);
+x_179 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_179, 0, x_178);
+lean_ctor_set(x_179, 1, x_177);
+return x_179;
 }
 }
 }
 else
 {
-lean_object* x_179; lean_object* x_180; 
+lean_object* x_180; lean_object* x_181; 
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
 lean_dec(x_3);
-x_179 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_179, 0, x_2);
-x_180 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_180, 0, x_179);
-lean_ctor_set(x_180, 1, x_11);
-return x_180;
+x_180 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_180, 0, x_2);
+x_181 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_181, 0, x_180);
+lean_ctor_set(x_181, 1, x_11);
+return x_181;
 }
 }
 block_22:
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Replace.c b/stage0/stdlib/Lean/Meta/Tactic/Replace.c
index 2937a4a773..d89d12cebb 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Replace.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Replace.c
@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Meta.Tactic.Replace
-// Imports: Init Lean.Util.ForEachExpr Lean.Meta.AppBuilder Lean.Meta.Tactic.Util Lean.Meta.Tactic.Revert Lean.Meta.Tactic.Intro Lean.Meta.Tactic.Clear Lean.Meta.Tactic.Assert
+// Imports: Init Lean.Util.ForEachExpr Lean.Meta.AppBuilder Lean.Meta.MatchUtil Lean.Meta.Tactic.Util Lean.Meta.Tactic.Revert Lean.Meta.Tactic.Intro Lean.Meta.Tactic.Clear Lean.Meta.Tactic.Assert
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -18,6 +18,7 @@ lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_Meta_withMVarContext___at_Lean_Meta_admit___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l_Lean_LocalDecl_userName(lean_object*);
+lean_object* l_Lean_Meta_modifyTarget___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getMVarTag(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
@@ -27,10 +28,12 @@ lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Meta_change___lambda__2___closed__2;
 lean_object* l_ReaderT_bind___at_Lean_Meta_instMonadLCtxMetaM___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl___lambda__1___closed__4;
+lean_object* l_Lean_Meta_modifyTarget___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkEqMP(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_checkNotAssigned___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_replaceLocalDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl_match__2(lean_object*);
+lean_object* l_Lean_Meta_modifyTargetEqLHS_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkAppN(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl___closed__2;
 lean_object* l_Lean_Meta_change___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -44,7 +47,9 @@ lean_object* l_Lean_Meta_replaceTargetEq(lean_object*, lean_object*, lean_object
 lean_object* l_Lean_Meta_getMVarType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_replaceLocalDecl_match__1(lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
+extern lean_object* l_Lean_Meta_mkNoConfusion___closed__3;
 lean_object* l_Lean_Meta_changeLocalDecl_match__1(lean_object*);
+lean_object* l_Lean_Meta_modifyTargetEqLHS___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_replaceLocalDecl_findMaxFVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
 lean_object* l_Lean_Meta_clear(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -58,6 +63,7 @@ lean_object* l_Lean_Meta_revert(lean_object*, lean_object*, uint8_t, lean_object
 lean_object* l_Lean_Meta_change___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___at_Lean_Meta_ToHide_visitVisibleExpr_visit___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_replaceTargetEq___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_modifyTargetEqLHS_match__1(lean_object*);
 extern lean_object* l_Lean_KernelException_toMessageData___closed__15;
 lean_object* l_Lean_Meta_introNCore(lean_object*, lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_mkEqMPR___closed__2;
@@ -70,7 +76,9 @@ extern lean_object* l_myMacro____x40_Init_Notation___hyg_71____closed__2;
 lean_object* l_Lean_setEnv___at_Lean_Meta_setInlineAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_fvarId(lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_928____closed__7;
+lean_object* l_Lean_Meta_matchEq_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_throwTacticEx___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__3;
 lean_object* l_Lean_Meta_assignExprMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_index(lean_object*);
@@ -84,6 +92,7 @@ lean_object* l_Lean_Meta_changeLocalDecl___lambda__1___closed__2;
 lean_object* l_Lean_Meta_replaceTargetDefEq___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getLevel(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_modifyTarget(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isFVar(lean_object*);
 lean_object* l_Lean_mkForall(lean_object*, uint8_t, lean_object*, lean_object*);
@@ -99,14 +108,19 @@ lean_object* l_Lean_Meta_mkExpectedTypeHint(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_Meta_getLocalDecl___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl___lambda__1___closed__5;
 lean_object* l_Lean_Meta_replaceTargetEq___closed__2;
+lean_object* l_Lean_Meta_modifyTarget___closed__2;
 lean_object* l_Lean_Meta_mkFreshExprSyntheticOpaqueMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl___lambda__1___closed__3;
+lean_object* l_Lean_Meta_modifyTarget___closed__1;
 lean_object* l_Lean_Meta_mkEq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setMCtx(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_indentExpr(lean_object*);
 uint8_t l_Lean_Expr_hasFVar(lean_object*);
+lean_object* l_Lean_Meta_modifyTargetEqLHS(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
+lean_object* l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__2;
 lean_object* l_Lean_ForEachExpr_visit___at_Lean_Meta_replaceLocalDecl_findMaxFVar___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_changeLocalDecl___lambda__1(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_replaceTargetEq___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) {
@@ -3150,9 +3164,360 @@ x_11 = l_Lean_Meta_changeLocalDecl(x_1, x_2, x_3, x_10, x_5, x_6, x_7, x_8, x_9)
 return x_11;
 }
 }
+lean_object* l_Lean_Meta_modifyTarget___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; 
+lean_inc(x_1);
+x_9 = l_Lean_Meta_getMVarType(x_1, x_4, x_5, x_6, x_7, x_8);
+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_9, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_9, 1);
+lean_inc(x_11);
+lean_dec(x_9);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+x_12 = lean_apply_6(x_2, x_10, x_4, x_5, x_6, x_7, x_11);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; 
+x_13 = lean_ctor_get(x_12, 0);
+lean_inc(x_13);
+x_14 = lean_ctor_get(x_12, 1);
+lean_inc(x_14);
+lean_dec(x_12);
+x_15 = 0;
+x_16 = l_Lean_Meta_change(x_1, x_13, x_15, x_4, x_5, x_6, x_7, x_14);
+return x_16;
+}
+else
+{
+uint8_t x_17; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+x_17 = !lean_is_exclusive(x_12);
+if (x_17 == 0)
+{
+return x_12;
+}
+else
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_12, 0);
+x_19 = lean_ctor_get(x_12, 1);
+lean_inc(x_19);
+lean_inc(x_18);
+lean_dec(x_12);
+x_20 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_20, 0, x_18);
+lean_ctor_set(x_20, 1, x_19);
+return x_20;
+}
+}
+}
+else
+{
+uint8_t x_21; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+lean_dec(x_1);
+x_21 = !lean_is_exclusive(x_9);
+if (x_21 == 0)
+{
+return x_9;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_22 = lean_ctor_get(x_9, 0);
+x_23 = lean_ctor_get(x_9, 1);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_dec(x_9);
+x_24 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_24, 0, x_22);
+lean_ctor_set(x_24, 1, x_23);
+return x_24;
+}
+}
+}
+}
+static lean_object* _init_l_Lean_Meta_modifyTarget___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("modifyTarget");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Meta_modifyTarget___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Lean_Meta_modifyTarget___closed__1;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
+lean_object* l_Lean_Meta_modifyTarget(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+_start:
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_8 = l_Lean_Meta_modifyTarget___closed__2;
+lean_inc(x_1);
+x_9 = lean_alloc_closure((void*)(l_Lean_Meta_checkNotAssigned___boxed), 7, 2);
+lean_closure_set(x_9, 0, x_1);
+lean_closure_set(x_9, 1, x_8);
+lean_inc(x_1);
+x_10 = lean_alloc_closure((void*)(l_Lean_Meta_modifyTarget___lambda__1___boxed), 8, 2);
+lean_closure_set(x_10, 0, x_1);
+lean_closure_set(x_10, 1, x_2);
+x_11 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Meta_instMonadLCtxMetaM___spec__2___rarg), 7, 2);
+lean_closure_set(x_11, 0, x_9);
+lean_closure_set(x_11, 1, x_10);
+x_12 = l_Lean_Meta_withMVarContext___at_Lean_Meta_admit___spec__1___rarg(x_1, x_11, x_3, x_4, x_5, x_6, x_7);
+return x_12;
+}
+}
+lean_object* l_Lean_Meta_modifyTarget___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_modifyTarget___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
+lean_dec(x_3);
+return x_9;
+}
+}
+lean_object* l_Lean_Meta_modifyTargetEqLHS_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_5, 0);
+lean_inc(x_7);
+lean_dec(x_5);
+x_8 = lean_ctor_get(x_6, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+lean_dec(x_6);
+x_10 = lean_apply_3(x_2, x_7, x_8, x_9);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_Meta_modifyTargetEqLHS_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Meta_modifyTargetEqLHS_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("modifyTargetEqLHS");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__1;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Meta_mkNoConfusion___closed__3;
+x_2 = l_Lean_stringToMessageData(x_1);
+return x_2;
+}
+}
+lean_object* l_Lean_Meta_modifyTargetEqLHS___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; 
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+x_9 = l_Lean_Meta_matchEq_x3f(x_3, x_4, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_2);
+x_11 = lean_ctor_get(x_9, 1);
+lean_inc(x_11);
+lean_dec(x_9);
+x_12 = l_Lean_indentExpr(x_3);
+x_13 = l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__3;
+x_14 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_14, 0, x_13);
+lean_ctor_set(x_14, 1, x_12);
+x_15 = l_Lean_KernelException_toMessageData___closed__15;
+x_16 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_16, 0, x_14);
+lean_ctor_set(x_16, 1, x_15);
+x_17 = l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__2;
+x_18 = lean_box(0);
+x_19 = l_Lean_Meta_throwTacticEx___rarg(x_17, x_1, x_16, x_18, x_4, x_5, x_6, x_7, x_11);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+return x_19;
+}
+else
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_20 = lean_ctor_get(x_10, 0);
+lean_inc(x_20);
+lean_dec(x_10);
+x_21 = lean_ctor_get(x_20, 1);
+lean_inc(x_21);
+lean_dec(x_20);
+x_22 = lean_ctor_get(x_9, 1);
+lean_inc(x_22);
+lean_dec(x_9);
+x_23 = lean_ctor_get(x_21, 0);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_21, 1);
+lean_inc(x_24);
+lean_dec(x_21);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+x_25 = lean_apply_6(x_2, x_23, x_4, x_5, x_6, x_7, x_22);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_26 = lean_ctor_get(x_25, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_25, 1);
+lean_inc(x_27);
+lean_dec(x_25);
+x_28 = l_Lean_Meta_mkEq(x_26, x_24, x_4, x_5, x_6, x_7, x_27);
+return x_28;
+}
+else
+{
+uint8_t x_29; 
+lean_dec(x_24);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_29 = !lean_is_exclusive(x_25);
+if (x_29 == 0)
+{
+return x_25;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_30 = lean_ctor_get(x_25, 0);
+x_31 = lean_ctor_get(x_25, 1);
+lean_inc(x_31);
+lean_inc(x_30);
+lean_dec(x_25);
+x_32 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_32, 0, x_30);
+lean_ctor_set(x_32, 1, x_31);
+return x_32;
+}
+}
+}
+}
+else
+{
+uint8_t x_33; 
+lean_dec(x_7);
+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_33 = !lean_is_exclusive(x_9);
+if (x_33 == 0)
+{
+return x_9;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_34 = lean_ctor_get(x_9, 0);
+x_35 = lean_ctor_get(x_9, 1);
+lean_inc(x_35);
+lean_inc(x_34);
+lean_dec(x_9);
+x_36 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_36, 0, x_34);
+lean_ctor_set(x_36, 1, x_35);
+return x_36;
+}
+}
+}
+}
+lean_object* l_Lean_Meta_modifyTargetEqLHS(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+_start:
+{
+lean_object* x_8; lean_object* x_9; 
+lean_inc(x_1);
+x_8 = lean_alloc_closure((void*)(l_Lean_Meta_modifyTargetEqLHS___lambda__1), 8, 2);
+lean_closure_set(x_8, 0, x_1);
+lean_closure_set(x_8, 1, x_2);
+x_9 = l_Lean_Meta_modifyTarget(x_1, x_8, x_3, x_4, x_5, x_6, x_7);
+return x_9;
+}
+}
 lean_object* initialize_Init(lean_object*);
 lean_object* initialize_Lean_Util_ForEachExpr(lean_object*);
 lean_object* initialize_Lean_Meta_AppBuilder(lean_object*);
+lean_object* initialize_Lean_Meta_MatchUtil(lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Util(lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Revert(lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Intro(lean_object*);
@@ -3172,6 +3537,9 @@ lean_dec_ref(res);
 res = initialize_Lean_Meta_AppBuilder(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Meta_MatchUtil(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
 res = initialize_Lean_Meta_Tactic_Util(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
@@ -3211,6 +3579,16 @@ l_Lean_Meta_changeLocalDecl___closed__1 = _init_l_Lean_Meta_changeLocalDecl___cl
 lean_mark_persistent(l_Lean_Meta_changeLocalDecl___closed__1);
 l_Lean_Meta_changeLocalDecl___closed__2 = _init_l_Lean_Meta_changeLocalDecl___closed__2();
 lean_mark_persistent(l_Lean_Meta_changeLocalDecl___closed__2);
+l_Lean_Meta_modifyTarget___closed__1 = _init_l_Lean_Meta_modifyTarget___closed__1();
+lean_mark_persistent(l_Lean_Meta_modifyTarget___closed__1);
+l_Lean_Meta_modifyTarget___closed__2 = _init_l_Lean_Meta_modifyTarget___closed__2();
+lean_mark_persistent(l_Lean_Meta_modifyTarget___closed__2);
+l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__1 = _init_l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__1();
+lean_mark_persistent(l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__1);
+l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__2 = _init_l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__2();
+lean_mark_persistent(l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__2);
+l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__3 = _init_l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__3();
+lean_mark_persistent(l_Lean_Meta_modifyTargetEqLHS___lambda__1___closed__3);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Rewrite.c b/stage0/stdlib/Lean/Meta/Tactic/Rewrite.c
index b48d20c047..65ac4f0991 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Rewrite.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Rewrite.c
@@ -1285,7 +1285,7 @@ return x_47;
 }
 else
 {
-uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
 x_48 = lean_ctor_get_uint8(x_19, 0);
 x_49 = lean_ctor_get_uint8(x_19, 1);
 x_50 = lean_ctor_get_uint8(x_19, 2);
@@ -1294,93 +1294,95 @@ x_52 = lean_ctor_get_uint8(x_19, 4);
 x_53 = lean_ctor_get_uint8(x_19, 6);
 x_54 = lean_ctor_get_uint8(x_19, 7);
 x_55 = lean_ctor_get_uint8(x_19, 8);
+x_56 = lean_ctor_get_uint8(x_19, 9);
 lean_dec(x_19);
-x_56 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_56, 0, x_48);
-lean_ctor_set_uint8(x_56, 1, x_49);
-lean_ctor_set_uint8(x_56, 2, x_50);
-lean_ctor_set_uint8(x_56, 3, x_51);
-lean_ctor_set_uint8(x_56, 4, x_52);
-lean_ctor_set_uint8(x_56, 5, x_2);
-lean_ctor_set_uint8(x_56, 6, x_53);
-lean_ctor_set_uint8(x_56, 7, x_54);
-lean_ctor_set_uint8(x_56, 8, x_55);
-x_57 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_57, 0, x_56);
-lean_ctor_set(x_57, 1, x_22);
-lean_ctor_set(x_57, 2, x_23);
-lean_ctor_set(x_57, 3, x_24);
+x_57 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_57, 0, x_48);
+lean_ctor_set_uint8(x_57, 1, x_49);
+lean_ctor_set_uint8(x_57, 2, x_50);
+lean_ctor_set_uint8(x_57, 3, x_51);
+lean_ctor_set_uint8(x_57, 4, x_52);
+lean_ctor_set_uint8(x_57, 5, x_2);
+lean_ctor_set_uint8(x_57, 6, x_53);
+lean_ctor_set_uint8(x_57, 7, x_54);
+lean_ctor_set_uint8(x_57, 8, x_55);
+lean_ctor_set_uint8(x_57, 9, x_56);
+x_58 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_58, 0, x_57);
+lean_ctor_set(x_58, 1, x_22);
+lean_ctor_set(x_58, 2, x_23);
+lean_ctor_set(x_58, 3, x_24);
 lean_inc(x_16);
 lean_inc(x_15);
 lean_inc(x_14);
 lean_inc(x_3);
 lean_inc(x_20);
-x_58 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_57, x_14, x_15, x_16, x_21);
-if (lean_obj_tag(x_58) == 0)
+x_59 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_58, x_14, x_15, x_16, x_21);
+if (lean_obj_tag(x_59) == 0)
 {
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_58, 1);
+lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+x_60 = lean_ctor_get(x_59, 0);
 lean_inc(x_60);
-lean_dec(x_58);
-x_61 = l_Lean_Expr_hasLooseBVars(x_59);
-if (x_61 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_61 = lean_ctor_get(x_59, 1);
+lean_inc(x_61);
 lean_dec(x_59);
+x_62 = l_Lean_Expr_hasLooseBVars(x_60);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_60);
 lean_dec(x_20);
 lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
-x_62 = l_Lean_indentExpr(x_3);
-x_63 = l_Lean_Meta_rewrite___lambda__3___closed__2;
-x_64 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_64, 0, x_63);
-lean_ctor_set(x_64, 1, x_62);
-x_65 = l_Lean_KernelException_toMessageData___closed__15;
-x_66 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_66, 0, x_64);
-lean_ctor_set(x_66, 1, x_65);
-x_67 = lean_box(0);
-x_68 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_66, x_67, x_13, x_14, x_15, x_16, x_60);
+x_63 = l_Lean_indentExpr(x_3);
+x_64 = l_Lean_Meta_rewrite___lambda__3___closed__2;
+x_65 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_65, 0, x_64);
+lean_ctor_set(x_65, 1, x_63);
+x_66 = l_Lean_KernelException_toMessageData___closed__15;
+x_67 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+x_68 = lean_box(0);
+x_69 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_67, x_68, x_13, x_14, x_15, x_16, x_61);
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
 lean_dec(x_13);
-x_69 = lean_ctor_get(x_68, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_68, 1);
+x_70 = lean_ctor_get(x_69, 0);
 lean_inc(x_70);
-if (lean_is_exclusive(x_68)) {
- lean_ctor_release(x_68, 0);
- lean_ctor_release(x_68, 1);
- x_71 = x_68;
+x_71 = lean_ctor_get(x_69, 1);
+lean_inc(x_71);
+if (lean_is_exclusive(x_69)) {
+ lean_ctor_release(x_69, 0);
+ lean_ctor_release(x_69, 1);
+ x_72 = x_69;
 } else {
- lean_dec_ref(x_68);
- x_71 = lean_box(0);
+ lean_dec_ref(x_69);
+ x_72 = lean_box(0);
 }
-if (lean_is_scalar(x_71)) {
- x_72 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_72)) {
+ x_73 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_72 = x_71;
+ x_73 = x_72;
 }
-lean_ctor_set(x_72, 0, x_69);
-lean_ctor_set(x_72, 1, x_70);
-return x_72;
+lean_ctor_set(x_73, 0, x_70);
+lean_ctor_set(x_73, 1, x_71);
+return x_73;
 }
 else
 {
-lean_object* x_73; lean_object* x_74; 
+lean_object* x_74; lean_object* x_75; 
 lean_dec(x_3);
-x_73 = lean_box(0);
-x_74 = l_Lean_Meta_rewrite___lambda__2(x_59, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_73, x_13, x_14, x_15, x_16, x_60);
-return x_74;
+x_74 = lean_box(0);
+x_75 = l_Lean_Meta_rewrite___lambda__2(x_60, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_74, x_13, x_14, x_15, x_16, x_61);
+return x_75;
 }
 }
 else
 {
-lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
 lean_dec(x_20);
 lean_dec(x_16);
 lean_dec(x_15);
@@ -1392,32 +1394,32 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_75 = lean_ctor_get(x_58, 0);
-lean_inc(x_75);
-x_76 = lean_ctor_get(x_58, 1);
+x_76 = lean_ctor_get(x_59, 0);
 lean_inc(x_76);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_77 = x_58;
+x_77 = lean_ctor_get(x_59, 1);
+lean_inc(x_77);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ x_78 = x_59;
 } else {
- lean_dec_ref(x_58);
- x_77 = lean_box(0);
+ lean_dec_ref(x_59);
+ x_78 = lean_box(0);
 }
-if (lean_is_scalar(x_77)) {
- x_78 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_78)) {
+ x_79 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_78 = x_77;
+ x_79 = x_78;
 }
-lean_ctor_set(x_78, 0, x_75);
-lean_ctor_set(x_78, 1, x_76);
-return x_78;
+lean_ctor_set(x_79, 0, x_76);
+lean_ctor_set(x_79, 1, x_77);
+return x_79;
 }
 }
 }
 else
 {
-uint8_t x_79; 
+uint8_t x_80; 
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
@@ -1428,23 +1430,23 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_79 = !lean_is_exclusive(x_18);
-if (x_79 == 0)
+x_80 = !lean_is_exclusive(x_18);
+if (x_80 == 0)
 {
 return x_18;
 }
 else
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-x_80 = lean_ctor_get(x_18, 0);
-x_81 = lean_ctor_get(x_18, 1);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_81 = lean_ctor_get(x_18, 0);
+x_82 = lean_ctor_get(x_18, 1);
+lean_inc(x_82);
 lean_inc(x_81);
-lean_inc(x_80);
 lean_dec(x_18);
-x_82 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_82, 0, x_80);
-lean_ctor_set(x_82, 1, x_81);
-return x_82;
+x_83 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_83, 0, x_81);
+lean_ctor_set(x_83, 1, x_82);
+return x_83;
 }
 }
 }
@@ -2111,7 +2113,7 @@ return x_47;
 }
 else
 {
-uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
 x_48 = lean_ctor_get_uint8(x_19, 0);
 x_49 = lean_ctor_get_uint8(x_19, 1);
 x_50 = lean_ctor_get_uint8(x_19, 2);
@@ -2120,93 +2122,95 @@ x_52 = lean_ctor_get_uint8(x_19, 4);
 x_53 = lean_ctor_get_uint8(x_19, 6);
 x_54 = lean_ctor_get_uint8(x_19, 7);
 x_55 = lean_ctor_get_uint8(x_19, 8);
+x_56 = lean_ctor_get_uint8(x_19, 9);
 lean_dec(x_19);
-x_56 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_56, 0, x_48);
-lean_ctor_set_uint8(x_56, 1, x_49);
-lean_ctor_set_uint8(x_56, 2, x_50);
-lean_ctor_set_uint8(x_56, 3, x_51);
-lean_ctor_set_uint8(x_56, 4, x_52);
-lean_ctor_set_uint8(x_56, 5, x_2);
-lean_ctor_set_uint8(x_56, 6, x_53);
-lean_ctor_set_uint8(x_56, 7, x_54);
-lean_ctor_set_uint8(x_56, 8, x_55);
-x_57 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_57, 0, x_56);
-lean_ctor_set(x_57, 1, x_22);
-lean_ctor_set(x_57, 2, x_23);
-lean_ctor_set(x_57, 3, x_24);
+x_57 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_57, 0, x_48);
+lean_ctor_set_uint8(x_57, 1, x_49);
+lean_ctor_set_uint8(x_57, 2, x_50);
+lean_ctor_set_uint8(x_57, 3, x_51);
+lean_ctor_set_uint8(x_57, 4, x_52);
+lean_ctor_set_uint8(x_57, 5, x_2);
+lean_ctor_set_uint8(x_57, 6, x_53);
+lean_ctor_set_uint8(x_57, 7, x_54);
+lean_ctor_set_uint8(x_57, 8, x_55);
+lean_ctor_set_uint8(x_57, 9, x_56);
+x_58 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_58, 0, x_57);
+lean_ctor_set(x_58, 1, x_22);
+lean_ctor_set(x_58, 2, x_23);
+lean_ctor_set(x_58, 3, x_24);
 lean_inc(x_16);
 lean_inc(x_15);
 lean_inc(x_14);
 lean_inc(x_3);
 lean_inc(x_20);
-x_58 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_57, x_14, x_15, x_16, x_21);
-if (lean_obj_tag(x_58) == 0)
+x_59 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_58, x_14, x_15, x_16, x_21);
+if (lean_obj_tag(x_59) == 0)
 {
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_58, 1);
+lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+x_60 = lean_ctor_get(x_59, 0);
 lean_inc(x_60);
-lean_dec(x_58);
-x_61 = l_Lean_Expr_hasLooseBVars(x_59);
-if (x_61 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_61 = lean_ctor_get(x_59, 1);
+lean_inc(x_61);
 lean_dec(x_59);
+x_62 = l_Lean_Expr_hasLooseBVars(x_60);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_60);
 lean_dec(x_20);
 lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
-x_62 = l_Lean_indentExpr(x_3);
-x_63 = l_Lean_Meta_rewrite___lambda__3___closed__2;
-x_64 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_64, 0, x_63);
-lean_ctor_set(x_64, 1, x_62);
-x_65 = l_Lean_KernelException_toMessageData___closed__15;
-x_66 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_66, 0, x_64);
-lean_ctor_set(x_66, 1, x_65);
-x_67 = lean_box(0);
-x_68 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_66, x_67, x_13, x_14, x_15, x_16, x_60);
+x_63 = l_Lean_indentExpr(x_3);
+x_64 = l_Lean_Meta_rewrite___lambda__3___closed__2;
+x_65 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_65, 0, x_64);
+lean_ctor_set(x_65, 1, x_63);
+x_66 = l_Lean_KernelException_toMessageData___closed__15;
+x_67 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+x_68 = lean_box(0);
+x_69 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_67, x_68, x_13, x_14, x_15, x_16, x_61);
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
 lean_dec(x_13);
-x_69 = lean_ctor_get(x_68, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_68, 1);
+x_70 = lean_ctor_get(x_69, 0);
 lean_inc(x_70);
-if (lean_is_exclusive(x_68)) {
- lean_ctor_release(x_68, 0);
- lean_ctor_release(x_68, 1);
- x_71 = x_68;
+x_71 = lean_ctor_get(x_69, 1);
+lean_inc(x_71);
+if (lean_is_exclusive(x_69)) {
+ lean_ctor_release(x_69, 0);
+ lean_ctor_release(x_69, 1);
+ x_72 = x_69;
 } else {
- lean_dec_ref(x_68);
- x_71 = lean_box(0);
+ lean_dec_ref(x_69);
+ x_72 = lean_box(0);
 }
-if (lean_is_scalar(x_71)) {
- x_72 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_72)) {
+ x_73 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_72 = x_71;
+ x_73 = x_72;
 }
-lean_ctor_set(x_72, 0, x_69);
-lean_ctor_set(x_72, 1, x_70);
-return x_72;
+lean_ctor_set(x_73, 0, x_70);
+lean_ctor_set(x_73, 1, x_71);
+return x_73;
 }
 else
 {
-lean_object* x_73; lean_object* x_74; 
+lean_object* x_74; lean_object* x_75; 
 lean_dec(x_3);
-x_73 = lean_box(0);
-x_74 = l_Lean_Meta_rewrite___lambda__5(x_59, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_73, x_13, x_14, x_15, x_16, x_60);
-return x_74;
+x_74 = lean_box(0);
+x_75 = l_Lean_Meta_rewrite___lambda__5(x_60, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_74, x_13, x_14, x_15, x_16, x_61);
+return x_75;
 }
 }
 else
 {
-lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
 lean_dec(x_20);
 lean_dec(x_16);
 lean_dec(x_15);
@@ -2218,32 +2222,32 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_75 = lean_ctor_get(x_58, 0);
-lean_inc(x_75);
-x_76 = lean_ctor_get(x_58, 1);
+x_76 = lean_ctor_get(x_59, 0);
 lean_inc(x_76);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_77 = x_58;
+x_77 = lean_ctor_get(x_59, 1);
+lean_inc(x_77);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ x_78 = x_59;
 } else {
- lean_dec_ref(x_58);
- x_77 = lean_box(0);
+ lean_dec_ref(x_59);
+ x_78 = lean_box(0);
 }
-if (lean_is_scalar(x_77)) {
- x_78 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_78)) {
+ x_79 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_78 = x_77;
+ x_79 = x_78;
 }
-lean_ctor_set(x_78, 0, x_75);
-lean_ctor_set(x_78, 1, x_76);
-return x_78;
+lean_ctor_set(x_79, 0, x_76);
+lean_ctor_set(x_79, 1, x_77);
+return x_79;
 }
 }
 }
 else
 {
-uint8_t x_79; 
+uint8_t x_80; 
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
@@ -2254,23 +2258,23 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_79 = !lean_is_exclusive(x_18);
-if (x_79 == 0)
+x_80 = !lean_is_exclusive(x_18);
+if (x_80 == 0)
 {
 return x_18;
 }
 else
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-x_80 = lean_ctor_get(x_18, 0);
-x_81 = lean_ctor_get(x_18, 1);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_81 = lean_ctor_get(x_18, 0);
+x_82 = lean_ctor_get(x_18, 1);
+lean_inc(x_82);
 lean_inc(x_81);
-lean_inc(x_80);
 lean_dec(x_18);
-x_82 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_82, 0, x_80);
-lean_ctor_set(x_82, 1, x_81);
-return x_82;
+x_83 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_83, 0, x_81);
+lean_ctor_set(x_83, 1, x_82);
+return x_83;
 }
 }
 }
@@ -2937,7 +2941,7 @@ return x_47;
 }
 else
 {
-uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
 x_48 = lean_ctor_get_uint8(x_19, 0);
 x_49 = lean_ctor_get_uint8(x_19, 1);
 x_50 = lean_ctor_get_uint8(x_19, 2);
@@ -2946,93 +2950,95 @@ x_52 = lean_ctor_get_uint8(x_19, 4);
 x_53 = lean_ctor_get_uint8(x_19, 6);
 x_54 = lean_ctor_get_uint8(x_19, 7);
 x_55 = lean_ctor_get_uint8(x_19, 8);
+x_56 = lean_ctor_get_uint8(x_19, 9);
 lean_dec(x_19);
-x_56 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_56, 0, x_48);
-lean_ctor_set_uint8(x_56, 1, x_49);
-lean_ctor_set_uint8(x_56, 2, x_50);
-lean_ctor_set_uint8(x_56, 3, x_51);
-lean_ctor_set_uint8(x_56, 4, x_52);
-lean_ctor_set_uint8(x_56, 5, x_2);
-lean_ctor_set_uint8(x_56, 6, x_53);
-lean_ctor_set_uint8(x_56, 7, x_54);
-lean_ctor_set_uint8(x_56, 8, x_55);
-x_57 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_57, 0, x_56);
-lean_ctor_set(x_57, 1, x_22);
-lean_ctor_set(x_57, 2, x_23);
-lean_ctor_set(x_57, 3, x_24);
+x_57 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_57, 0, x_48);
+lean_ctor_set_uint8(x_57, 1, x_49);
+lean_ctor_set_uint8(x_57, 2, x_50);
+lean_ctor_set_uint8(x_57, 3, x_51);
+lean_ctor_set_uint8(x_57, 4, x_52);
+lean_ctor_set_uint8(x_57, 5, x_2);
+lean_ctor_set_uint8(x_57, 6, x_53);
+lean_ctor_set_uint8(x_57, 7, x_54);
+lean_ctor_set_uint8(x_57, 8, x_55);
+lean_ctor_set_uint8(x_57, 9, x_56);
+x_58 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_58, 0, x_57);
+lean_ctor_set(x_58, 1, x_22);
+lean_ctor_set(x_58, 2, x_23);
+lean_ctor_set(x_58, 3, x_24);
 lean_inc(x_16);
 lean_inc(x_15);
 lean_inc(x_14);
 lean_inc(x_3);
 lean_inc(x_20);
-x_58 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_57, x_14, x_15, x_16, x_21);
-if (lean_obj_tag(x_58) == 0)
+x_59 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_58, x_14, x_15, x_16, x_21);
+if (lean_obj_tag(x_59) == 0)
 {
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_58, 1);
+lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+x_60 = lean_ctor_get(x_59, 0);
 lean_inc(x_60);
-lean_dec(x_58);
-x_61 = l_Lean_Expr_hasLooseBVars(x_59);
-if (x_61 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_61 = lean_ctor_get(x_59, 1);
+lean_inc(x_61);
 lean_dec(x_59);
+x_62 = l_Lean_Expr_hasLooseBVars(x_60);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_60);
 lean_dec(x_20);
 lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
-x_62 = l_Lean_indentExpr(x_3);
-x_63 = l_Lean_Meta_rewrite___lambda__3___closed__2;
-x_64 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_64, 0, x_63);
-lean_ctor_set(x_64, 1, x_62);
-x_65 = l_Lean_KernelException_toMessageData___closed__15;
-x_66 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_66, 0, x_64);
-lean_ctor_set(x_66, 1, x_65);
-x_67 = lean_box(0);
-x_68 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_66, x_67, x_13, x_14, x_15, x_16, x_60);
+x_63 = l_Lean_indentExpr(x_3);
+x_64 = l_Lean_Meta_rewrite___lambda__3___closed__2;
+x_65 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_65, 0, x_64);
+lean_ctor_set(x_65, 1, x_63);
+x_66 = l_Lean_KernelException_toMessageData___closed__15;
+x_67 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+x_68 = lean_box(0);
+x_69 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_67, x_68, x_13, x_14, x_15, x_16, x_61);
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
 lean_dec(x_13);
-x_69 = lean_ctor_get(x_68, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_68, 1);
+x_70 = lean_ctor_get(x_69, 0);
 lean_inc(x_70);
-if (lean_is_exclusive(x_68)) {
- lean_ctor_release(x_68, 0);
- lean_ctor_release(x_68, 1);
- x_71 = x_68;
+x_71 = lean_ctor_get(x_69, 1);
+lean_inc(x_71);
+if (lean_is_exclusive(x_69)) {
+ lean_ctor_release(x_69, 0);
+ lean_ctor_release(x_69, 1);
+ x_72 = x_69;
 } else {
- lean_dec_ref(x_68);
- x_71 = lean_box(0);
+ lean_dec_ref(x_69);
+ x_72 = lean_box(0);
 }
-if (lean_is_scalar(x_71)) {
- x_72 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_72)) {
+ x_73 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_72 = x_71;
+ x_73 = x_72;
 }
-lean_ctor_set(x_72, 0, x_69);
-lean_ctor_set(x_72, 1, x_70);
-return x_72;
+lean_ctor_set(x_73, 0, x_70);
+lean_ctor_set(x_73, 1, x_71);
+return x_73;
 }
 else
 {
-lean_object* x_73; lean_object* x_74; 
+lean_object* x_74; lean_object* x_75; 
 lean_dec(x_3);
-x_73 = lean_box(0);
-x_74 = l_Lean_Meta_rewrite___lambda__8(x_59, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_73, x_13, x_14, x_15, x_16, x_60);
-return x_74;
+x_74 = lean_box(0);
+x_75 = l_Lean_Meta_rewrite___lambda__8(x_60, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_74, x_13, x_14, x_15, x_16, x_61);
+return x_75;
 }
 }
 else
 {
-lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
 lean_dec(x_20);
 lean_dec(x_16);
 lean_dec(x_15);
@@ -3044,32 +3050,32 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_75 = lean_ctor_get(x_58, 0);
-lean_inc(x_75);
-x_76 = lean_ctor_get(x_58, 1);
+x_76 = lean_ctor_get(x_59, 0);
 lean_inc(x_76);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_77 = x_58;
+x_77 = lean_ctor_get(x_59, 1);
+lean_inc(x_77);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ x_78 = x_59;
 } else {
- lean_dec_ref(x_58);
- x_77 = lean_box(0);
+ lean_dec_ref(x_59);
+ x_78 = lean_box(0);
 }
-if (lean_is_scalar(x_77)) {
- x_78 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_78)) {
+ x_79 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_78 = x_77;
+ x_79 = x_78;
 }
-lean_ctor_set(x_78, 0, x_75);
-lean_ctor_set(x_78, 1, x_76);
-return x_78;
+lean_ctor_set(x_79, 0, x_76);
+lean_ctor_set(x_79, 1, x_77);
+return x_79;
 }
 }
 }
 else
 {
-uint8_t x_79; 
+uint8_t x_80; 
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
@@ -3080,23 +3086,23 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_79 = !lean_is_exclusive(x_18);
-if (x_79 == 0)
+x_80 = !lean_is_exclusive(x_18);
+if (x_80 == 0)
 {
 return x_18;
 }
 else
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-x_80 = lean_ctor_get(x_18, 0);
-x_81 = lean_ctor_get(x_18, 1);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_81 = lean_ctor_get(x_18, 0);
+x_82 = lean_ctor_get(x_18, 1);
+lean_inc(x_82);
 lean_inc(x_81);
-lean_inc(x_80);
 lean_dec(x_18);
-x_82 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_82, 0, x_80);
-lean_ctor_set(x_82, 1, x_81);
-return x_82;
+x_83 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_83, 0, x_81);
+lean_ctor_set(x_83, 1, x_82);
+return x_83;
 }
 }
 }
@@ -3763,7 +3769,7 @@ return x_47;
 }
 else
 {
-uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
 x_48 = lean_ctor_get_uint8(x_19, 0);
 x_49 = lean_ctor_get_uint8(x_19, 1);
 x_50 = lean_ctor_get_uint8(x_19, 2);
@@ -3772,93 +3778,95 @@ x_52 = lean_ctor_get_uint8(x_19, 4);
 x_53 = lean_ctor_get_uint8(x_19, 6);
 x_54 = lean_ctor_get_uint8(x_19, 7);
 x_55 = lean_ctor_get_uint8(x_19, 8);
+x_56 = lean_ctor_get_uint8(x_19, 9);
 lean_dec(x_19);
-x_56 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_56, 0, x_48);
-lean_ctor_set_uint8(x_56, 1, x_49);
-lean_ctor_set_uint8(x_56, 2, x_50);
-lean_ctor_set_uint8(x_56, 3, x_51);
-lean_ctor_set_uint8(x_56, 4, x_52);
-lean_ctor_set_uint8(x_56, 5, x_2);
-lean_ctor_set_uint8(x_56, 6, x_53);
-lean_ctor_set_uint8(x_56, 7, x_54);
-lean_ctor_set_uint8(x_56, 8, x_55);
-x_57 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_57, 0, x_56);
-lean_ctor_set(x_57, 1, x_22);
-lean_ctor_set(x_57, 2, x_23);
-lean_ctor_set(x_57, 3, x_24);
+x_57 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_57, 0, x_48);
+lean_ctor_set_uint8(x_57, 1, x_49);
+lean_ctor_set_uint8(x_57, 2, x_50);
+lean_ctor_set_uint8(x_57, 3, x_51);
+lean_ctor_set_uint8(x_57, 4, x_52);
+lean_ctor_set_uint8(x_57, 5, x_2);
+lean_ctor_set_uint8(x_57, 6, x_53);
+lean_ctor_set_uint8(x_57, 7, x_54);
+lean_ctor_set_uint8(x_57, 8, x_55);
+lean_ctor_set_uint8(x_57, 9, x_56);
+x_58 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_58, 0, x_57);
+lean_ctor_set(x_58, 1, x_22);
+lean_ctor_set(x_58, 2, x_23);
+lean_ctor_set(x_58, 3, x_24);
 lean_inc(x_16);
 lean_inc(x_15);
 lean_inc(x_14);
 lean_inc(x_3);
 lean_inc(x_20);
-x_58 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_57, x_14, x_15, x_16, x_21);
-if (lean_obj_tag(x_58) == 0)
+x_59 = l_Lean_Meta_kabstract(x_20, x_3, x_4, x_58, x_14, x_15, x_16, x_21);
+if (lean_obj_tag(x_59) == 0)
 {
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_58, 1);
+lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+x_60 = lean_ctor_get(x_59, 0);
 lean_inc(x_60);
-lean_dec(x_58);
-x_61 = l_Lean_Expr_hasLooseBVars(x_59);
-if (x_61 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_61 = lean_ctor_get(x_59, 1);
+lean_inc(x_61);
 lean_dec(x_59);
+x_62 = l_Lean_Expr_hasLooseBVars(x_60);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_60);
 lean_dec(x_20);
 lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
-x_62 = l_Lean_indentExpr(x_3);
-x_63 = l_Lean_Meta_rewrite___lambda__3___closed__2;
-x_64 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_64, 0, x_63);
-lean_ctor_set(x_64, 1, x_62);
-x_65 = l_Lean_KernelException_toMessageData___closed__15;
-x_66 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_66, 0, x_64);
-lean_ctor_set(x_66, 1, x_65);
-x_67 = lean_box(0);
-x_68 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_66, x_67, x_13, x_14, x_15, x_16, x_60);
+x_63 = l_Lean_indentExpr(x_3);
+x_64 = l_Lean_Meta_rewrite___lambda__3___closed__2;
+x_65 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_65, 0, x_64);
+lean_ctor_set(x_65, 1, x_63);
+x_66 = l_Lean_KernelException_toMessageData___closed__15;
+x_67 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+x_68 = lean_box(0);
+x_69 = l_Lean_Meta_throwTacticEx___rarg(x_8, x_9, x_67, x_68, x_13, x_14, x_15, x_16, x_61);
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
 lean_dec(x_13);
-x_69 = lean_ctor_get(x_68, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_68, 1);
+x_70 = lean_ctor_get(x_69, 0);
 lean_inc(x_70);
-if (lean_is_exclusive(x_68)) {
- lean_ctor_release(x_68, 0);
- lean_ctor_release(x_68, 1);
- x_71 = x_68;
+x_71 = lean_ctor_get(x_69, 1);
+lean_inc(x_71);
+if (lean_is_exclusive(x_69)) {
+ lean_ctor_release(x_69, 0);
+ lean_ctor_release(x_69, 1);
+ x_72 = x_69;
 } else {
- lean_dec_ref(x_68);
- x_71 = lean_box(0);
+ lean_dec_ref(x_69);
+ x_72 = lean_box(0);
 }
-if (lean_is_scalar(x_71)) {
- x_72 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_72)) {
+ x_73 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_72 = x_71;
+ x_73 = x_72;
 }
-lean_ctor_set(x_72, 0, x_69);
-lean_ctor_set(x_72, 1, x_70);
-return x_72;
+lean_ctor_set(x_73, 0, x_70);
+lean_ctor_set(x_73, 1, x_71);
+return x_73;
 }
 else
 {
-lean_object* x_73; lean_object* x_74; 
+lean_object* x_74; lean_object* x_75; 
 lean_dec(x_3);
-x_73 = lean_box(0);
-x_74 = l_Lean_Meta_rewrite___lambda__11(x_59, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_73, x_13, x_14, x_15, x_16, x_60);
-return x_74;
+x_74 = lean_box(0);
+x_75 = l_Lean_Meta_rewrite___lambda__11(x_60, x_5, x_20, x_6, x_7, x_8, x_9, x_10, x_11, x_74, x_13, x_14, x_15, x_16, x_61);
+return x_75;
 }
 }
 else
 {
-lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
 lean_dec(x_20);
 lean_dec(x_16);
 lean_dec(x_15);
@@ -3870,32 +3878,32 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_75 = lean_ctor_get(x_58, 0);
-lean_inc(x_75);
-x_76 = lean_ctor_get(x_58, 1);
+x_76 = lean_ctor_get(x_59, 0);
 lean_inc(x_76);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- x_77 = x_58;
+x_77 = lean_ctor_get(x_59, 1);
+lean_inc(x_77);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ x_78 = x_59;
 } else {
- lean_dec_ref(x_58);
- x_77 = lean_box(0);
+ lean_dec_ref(x_59);
+ x_78 = lean_box(0);
 }
-if (lean_is_scalar(x_77)) {
- x_78 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_78)) {
+ x_79 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_78 = x_77;
+ x_79 = x_78;
 }
-lean_ctor_set(x_78, 0, x_75);
-lean_ctor_set(x_78, 1, x_76);
-return x_78;
+lean_ctor_set(x_79, 0, x_76);
+lean_ctor_set(x_79, 1, x_77);
+return x_79;
 }
 }
 }
 else
 {
-uint8_t x_79; 
+uint8_t x_80; 
 lean_dec(x_16);
 lean_dec(x_15);
 lean_dec(x_14);
@@ -3906,23 +3914,23 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_79 = !lean_is_exclusive(x_18);
-if (x_79 == 0)
+x_80 = !lean_is_exclusive(x_18);
+if (x_80 == 0)
 {
 return x_18;
 }
 else
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-x_80 = lean_ctor_get(x_18, 0);
-x_81 = lean_ctor_get(x_18, 1);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_81 = lean_ctor_get(x_18, 0);
+x_82 = lean_ctor_get(x_18, 1);
+lean_inc(x_82);
 lean_inc(x_81);
-lean_inc(x_80);
 lean_dec(x_18);
-x_82 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_82, 0, x_80);
-lean_ctor_set(x_82, 1, x_81);
-return x_82;
+x_83 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_83, 0, x_81);
+lean_ctor_set(x_83, 1, x_82);
+return x_83;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Simp/CongrLemmas.c b/stage0/stdlib/Lean/Meta/Tactic/Simp/CongrLemmas.c
index f3ffb937d5..1dc8d1b2cc 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Simp/CongrLemmas.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Simp/CongrLemmas.c
@@ -189,6 +189,7 @@ lean_object* l_Std_PersistentHashMap_foldlM___at___private_Lean_Meta_Tactic_Simp
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_mkCongrLemma___spec__5___closed__4;
 lean_object* l_Std_PersistentHashMap_insertAux___at_Lean_Meta_addCongrLemmaEntry___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_CongrLemmas_get_match__1(lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 size_t l_Lean_Name_hash(lean_object*);
 lean_object* l_Lean_Meta_mkCongrLemma___closed__2;
 lean_object* l_Nat_repr(lean_object*);
@@ -197,7 +198,6 @@ lean_object* l_Lean_throwError___at_Lean_Meta_mkCongrLemma___spec__2___boxed(lea
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___at___private_Lean_Meta_Tactic_Simp_CongrLemmas_0__Lean_Meta_reprCongrLemmas____x40_Lean_Meta_Tactic_Simp_CongrLemmas___hyg_156____spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_CongrLemmas_lemmas___default___closed__2;
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
 lean_object* l_Std_PersistentHashMap_foldlM___at___private_Lean_Meta_Tactic_Simp_CongrLemmas_0__Lean_Meta_reprCongrLemmas____x40_Lean_Meta_Tactic_Simp_CongrLemmas___hyg_156____spec__8___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_to_list(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkCongrLemma___closed__1;
@@ -6499,7 +6499,7 @@ lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean
 x_70 = lean_ctor_get(x_64, 1);
 lean_inc(x_70);
 lean_dec(x_64);
-x_71 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_71 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_72 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at_Lean_Meta_mkCongrLemma___spec__8(x_71, x_12, x_13, x_14, x_15, x_70);
 x_73 = lean_ctor_get(x_72, 0);
 lean_inc(x_73);
@@ -6561,7 +6561,7 @@ x_51 = l_Lean_KernelException_toMessageData___closed__15;
 x_52 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_52, 0, x_50);
 lean_ctor_set(x_52, 1, x_51);
-x_53 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_53 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_54 = l_Lean_addTrace___at_Lean_Meta_mkCongrLemma___spec__7(x_53, x_52, x_12, x_13, x_14, x_15, x_40);
 lean_dec(x_15);
 lean_dec(x_14);
@@ -7237,7 +7237,7 @@ return x_70;
 }
 else
 {
-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; uint8_t x_79; lean_object* x_80; lean_object* x_81; 
+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; uint8_t x_79; uint8_t x_80; lean_object* x_81; lean_object* x_82; 
 x_71 = lean_ctor_get_uint8(x_9, 0);
 x_72 = lean_ctor_get_uint8(x_9, 1);
 x_73 = lean_ctor_get_uint8(x_9, 2);
@@ -7246,582 +7246,586 @@ x_75 = lean_ctor_get_uint8(x_9, 4);
 x_76 = lean_ctor_get_uint8(x_9, 6);
 x_77 = lean_ctor_get_uint8(x_9, 7);
 x_78 = lean_ctor_get_uint8(x_9, 8);
+x_79 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_79 = 2;
-x_80 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_80, 0, x_71);
-lean_ctor_set_uint8(x_80, 1, x_72);
-lean_ctor_set_uint8(x_80, 2, x_73);
-lean_ctor_set_uint8(x_80, 3, x_74);
-lean_ctor_set_uint8(x_80, 4, x_75);
-lean_ctor_set_uint8(x_80, 5, x_79);
-lean_ctor_set_uint8(x_80, 6, x_76);
-lean_ctor_set_uint8(x_80, 7, x_77);
-lean_ctor_set_uint8(x_80, 8, x_78);
-lean_ctor_set(x_3, 0, x_80);
+x_80 = 2;
+x_81 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_81, 0, x_71);
+lean_ctor_set_uint8(x_81, 1, x_72);
+lean_ctor_set_uint8(x_81, 2, x_73);
+lean_ctor_set_uint8(x_81, 3, x_74);
+lean_ctor_set_uint8(x_81, 4, x_75);
+lean_ctor_set_uint8(x_81, 5, x_80);
+lean_ctor_set_uint8(x_81, 6, x_76);
+lean_ctor_set_uint8(x_81, 7, x_77);
+lean_ctor_set_uint8(x_81, 8, x_78);
+lean_ctor_set_uint8(x_81, 9, x_79);
+lean_ctor_set(x_3, 0, x_81);
 lean_inc(x_1);
-x_81 = l_Lean_mkConstWithLevelParams___at_Lean_Meta_mkCongrLemma___spec__1(x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_81) == 0)
+x_82 = l_Lean_mkConstWithLevelParams___at_Lean_Meta_mkCongrLemma___spec__1(x_1, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_82) == 0)
 {
-lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_82 = lean_ctor_get(x_81, 0);
-lean_inc(x_82);
-x_83 = lean_ctor_get(x_81, 1);
+lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+x_83 = lean_ctor_get(x_82, 0);
 lean_inc(x_83);
-lean_dec(x_81);
+x_84 = lean_ctor_get(x_82, 1);
+lean_inc(x_84);
+lean_dec(x_82);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_82);
-x_84 = l_Lean_Meta_inferType(x_82, x_3, x_4, x_5, x_6, x_83);
-if (lean_obj_tag(x_84) == 0)
+lean_inc(x_83);
+x_85 = l_Lean_Meta_inferType(x_83, x_3, x_4, x_5, x_6, x_84);
+if (lean_obj_tag(x_85) == 0)
 {
-lean_object* x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; uint8_t x_89; lean_object* x_90; 
-x_85 = lean_ctor_get(x_84, 0);
-lean_inc(x_85);
-x_86 = lean_ctor_get(x_84, 1);
+lean_object* x_86; lean_object* x_87; lean_object* x_88; uint8_t x_89; uint8_t x_90; lean_object* x_91; 
+x_86 = lean_ctor_get(x_85, 0);
 lean_inc(x_86);
-lean_dec(x_84);
-x_87 = lean_box(0);
-x_88 = 1;
-x_89 = 0;
+x_87 = lean_ctor_get(x_85, 1);
+lean_inc(x_87);
+lean_dec(x_85);
+x_88 = lean_box(0);
+x_89 = 1;
+x_90 = 0;
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_90 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_85, x_88, x_87, x_89, x_3, x_4, x_5, x_6, x_86);
-if (lean_obj_tag(x_90) == 0)
+x_91 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_86, x_89, x_88, x_90, x_3, x_4, x_5, x_6, x_87);
+if (lean_obj_tag(x_91) == 0)
 {
-lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; uint8_t x_99; 
-x_91 = lean_ctor_get(x_90, 0);
-lean_inc(x_91);
-x_92 = lean_ctor_get(x_91, 1);
+lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; 
+x_92 = lean_ctor_get(x_91, 0);
 lean_inc(x_92);
-x_93 = lean_ctor_get(x_90, 1);
+x_93 = lean_ctor_get(x_92, 1);
 lean_inc(x_93);
-lean_dec(x_90);
-x_94 = lean_ctor_get(x_91, 0);
+x_94 = lean_ctor_get(x_91, 1);
 lean_inc(x_94);
 lean_dec(x_91);
 x_95 = lean_ctor_get(x_92, 0);
 lean_inc(x_95);
-x_96 = lean_ctor_get(x_92, 1);
-lean_inc(x_96);
 lean_dec(x_92);
-x_97 = l_myMacro____x40_Init_Notation___hyg_7553____closed__4;
-x_98 = lean_unsigned_to_nat(3u);
-x_99 = l_Lean_Expr_isAppOfArity(x_96, x_97, x_98);
-if (x_99 == 0)
+x_96 = lean_ctor_get(x_93, 0);
+lean_inc(x_96);
+x_97 = lean_ctor_get(x_93, 1);
+lean_inc(x_97);
+lean_dec(x_93);
+x_98 = l_myMacro____x40_Init_Notation___hyg_7553____closed__4;
+x_99 = lean_unsigned_to_nat(3u);
+x_100 = l_Lean_Expr_isAppOfArity(x_97, x_98, x_99);
+if (x_100 == 0)
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; 
+lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; 
+lean_dec(x_96);
 lean_dec(x_95);
-lean_dec(x_94);
-lean_dec(x_82);
+lean_dec(x_83);
 lean_dec(x_2);
 lean_dec(x_1);
-x_100 = l_Lean_indentExpr(x_96);
-x_101 = l_Lean_Meta_mkCongrLemma___closed__2;
-x_102 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_102, 0, x_101);
-lean_ctor_set(x_102, 1, x_100);
-x_103 = l_Lean_KernelException_toMessageData___closed__15;
-x_104 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_104, 0, x_102);
-lean_ctor_set(x_104, 1, x_103);
-x_105 = l_Lean_throwError___at_Lean_Meta_mkCongrLemma___spec__2(x_104, x_3, x_4, x_5, x_6, x_93);
+x_101 = l_Lean_indentExpr(x_97);
+x_102 = l_Lean_Meta_mkCongrLemma___closed__2;
+x_103 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_103, 0, x_102);
+lean_ctor_set(x_103, 1, x_101);
+x_104 = l_Lean_KernelException_toMessageData___closed__15;
+x_105 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_105, 0, x_103);
+lean_ctor_set(x_105, 1, x_104);
+x_106 = l_Lean_throwError___at_Lean_Meta_mkCongrLemma___spec__2(x_105, x_3, x_4, x_5, x_6, x_94);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_106 = lean_ctor_get(x_105, 0);
-lean_inc(x_106);
-x_107 = lean_ctor_get(x_105, 1);
+x_107 = lean_ctor_get(x_106, 0);
 lean_inc(x_107);
-if (lean_is_exclusive(x_105)) {
- lean_ctor_release(x_105, 0);
- lean_ctor_release(x_105, 1);
- x_108 = x_105;
+x_108 = lean_ctor_get(x_106, 1);
+lean_inc(x_108);
+if (lean_is_exclusive(x_106)) {
+ lean_ctor_release(x_106, 0);
+ lean_ctor_release(x_106, 1);
+ x_109 = x_106;
 } else {
- lean_dec_ref(x_105);
- x_108 = lean_box(0);
+ lean_dec_ref(x_106);
+ x_109 = lean_box(0);
 }
-if (lean_is_scalar(x_108)) {
- x_109 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_109)) {
+ x_110 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_109 = x_108;
+ x_110 = x_109;
 }
-lean_ctor_set(x_109, 0, x_106);
-lean_ctor_set(x_109, 1, x_107);
-return x_109;
+lean_ctor_set(x_110, 0, x_107);
+lean_ctor_set(x_110, 1, x_108);
+return x_110;
 }
 else
 {
-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; 
-x_110 = l_Lean_Expr_appFn_x21(x_96);
-x_111 = l_Lean_Expr_appArg_x21(x_110);
-lean_dec(x_110);
-x_112 = l_Lean_Expr_appArg_x21(x_96);
-x_113 = lean_unsigned_to_nat(0u);
-x_114 = l_Lean_Expr_getAppNumArgsAux(x_111, x_113);
-x_115 = l_Lean_Expr_getAppArgs___closed__1;
-lean_inc(x_114);
-x_116 = lean_mk_array(x_114, x_115);
-x_117 = lean_unsigned_to_nat(1u);
-x_118 = lean_nat_sub(x_114, x_117);
-lean_dec(x_114);
-lean_inc(x_111);
-x_119 = l_Lean_Expr_withAppAux___at_Lean_Meta_mkCongrLemma___spec__10(x_1, x_2, x_82, x_94, x_95, x_96, x_97, x_111, x_112, x_111, x_116, x_118, x_3, x_4, x_5, x_6, x_93);
-lean_dec(x_94);
-if (lean_obj_tag(x_119) == 0)
+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_111 = l_Lean_Expr_appFn_x21(x_97);
+x_112 = l_Lean_Expr_appArg_x21(x_111);
+lean_dec(x_111);
+x_113 = l_Lean_Expr_appArg_x21(x_97);
+x_114 = lean_unsigned_to_nat(0u);
+x_115 = l_Lean_Expr_getAppNumArgsAux(x_112, x_114);
+x_116 = l_Lean_Expr_getAppArgs___closed__1;
+lean_inc(x_115);
+x_117 = lean_mk_array(x_115, x_116);
+x_118 = lean_unsigned_to_nat(1u);
+x_119 = lean_nat_sub(x_115, x_118);
+lean_dec(x_115);
+lean_inc(x_112);
+x_120 = l_Lean_Expr_withAppAux___at_Lean_Meta_mkCongrLemma___spec__10(x_1, x_2, x_83, x_95, x_96, x_97, x_98, x_112, x_113, x_112, x_117, x_119, x_3, x_4, x_5, x_6, x_94);
+lean_dec(x_95);
+if (lean_obj_tag(x_120) == 0)
 {
-lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; 
-x_120 = lean_ctor_get(x_119, 0);
-lean_inc(x_120);
-x_121 = lean_ctor_get(x_119, 1);
+lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; 
+x_121 = lean_ctor_get(x_120, 0);
 lean_inc(x_121);
-if (lean_is_exclusive(x_119)) {
- lean_ctor_release(x_119, 0);
- lean_ctor_release(x_119, 1);
- x_122 = x_119;
+x_122 = lean_ctor_get(x_120, 1);
+lean_inc(x_122);
+if (lean_is_exclusive(x_120)) {
+ lean_ctor_release(x_120, 0);
+ lean_ctor_release(x_120, 1);
+ x_123 = x_120;
 } else {
- lean_dec_ref(x_119);
- x_122 = lean_box(0);
+ lean_dec_ref(x_120);
+ x_123 = lean_box(0);
 }
-if (lean_is_scalar(x_122)) {
- x_123 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_123)) {
+ x_124 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_123 = x_122;
+ x_124 = x_123;
 }
-lean_ctor_set(x_123, 0, x_120);
-lean_ctor_set(x_123, 1, x_121);
-return x_123;
+lean_ctor_set(x_124, 0, x_121);
+lean_ctor_set(x_124, 1, x_122);
+return x_124;
 }
 else
 {
-lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; 
-x_124 = lean_ctor_get(x_119, 0);
-lean_inc(x_124);
-x_125 = lean_ctor_get(x_119, 1);
+lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; 
+x_125 = lean_ctor_get(x_120, 0);
 lean_inc(x_125);
-if (lean_is_exclusive(x_119)) {
- lean_ctor_release(x_119, 0);
- lean_ctor_release(x_119, 1);
- x_126 = x_119;
+x_126 = lean_ctor_get(x_120, 1);
+lean_inc(x_126);
+if (lean_is_exclusive(x_120)) {
+ lean_ctor_release(x_120, 0);
+ lean_ctor_release(x_120, 1);
+ x_127 = x_120;
 } else {
- lean_dec_ref(x_119);
- x_126 = lean_box(0);
+ lean_dec_ref(x_120);
+ x_127 = lean_box(0);
 }
-if (lean_is_scalar(x_126)) {
- x_127 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_127)) {
+ x_128 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_127 = x_126;
+ x_128 = x_127;
 }
-lean_ctor_set(x_127, 0, x_124);
-lean_ctor_set(x_127, 1, x_125);
-return x_127;
+lean_ctor_set(x_128, 0, x_125);
+lean_ctor_set(x_128, 1, x_126);
+return x_128;
 }
 }
 }
 else
 {
-lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; 
-lean_dec(x_82);
+lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; 
+lean_dec(x_83);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_128 = lean_ctor_get(x_90, 0);
-lean_inc(x_128);
-x_129 = lean_ctor_get(x_90, 1);
+x_129 = lean_ctor_get(x_91, 0);
 lean_inc(x_129);
-if (lean_is_exclusive(x_90)) {
- lean_ctor_release(x_90, 0);
- lean_ctor_release(x_90, 1);
- x_130 = x_90;
+x_130 = lean_ctor_get(x_91, 1);
+lean_inc(x_130);
+if (lean_is_exclusive(x_91)) {
+ lean_ctor_release(x_91, 0);
+ lean_ctor_release(x_91, 1);
+ x_131 = x_91;
 } else {
- lean_dec_ref(x_90);
- x_130 = lean_box(0);
+ lean_dec_ref(x_91);
+ x_131 = lean_box(0);
 }
-if (lean_is_scalar(x_130)) {
- x_131 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_131)) {
+ x_132 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_131 = x_130;
+ x_132 = x_131;
 }
-lean_ctor_set(x_131, 0, x_128);
-lean_ctor_set(x_131, 1, x_129);
-return x_131;
+lean_ctor_set(x_132, 0, x_129);
+lean_ctor_set(x_132, 1, x_130);
+return x_132;
 }
 }
 else
 {
-lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
-lean_dec(x_82);
+lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
+lean_dec(x_83);
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_132 = lean_ctor_get(x_84, 0);
-lean_inc(x_132);
-x_133 = lean_ctor_get(x_84, 1);
+x_133 = lean_ctor_get(x_85, 0);
 lean_inc(x_133);
-if (lean_is_exclusive(x_84)) {
- lean_ctor_release(x_84, 0);
- lean_ctor_release(x_84, 1);
- x_134 = x_84;
+x_134 = lean_ctor_get(x_85, 1);
+lean_inc(x_134);
+if (lean_is_exclusive(x_85)) {
+ lean_ctor_release(x_85, 0);
+ lean_ctor_release(x_85, 1);
+ x_135 = x_85;
 } else {
- lean_dec_ref(x_84);
- x_134 = lean_box(0);
+ lean_dec_ref(x_85);
+ x_135 = lean_box(0);
 }
-if (lean_is_scalar(x_134)) {
- x_135 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_135)) {
+ x_136 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_135 = x_134;
+ x_136 = x_135;
 }
-lean_ctor_set(x_135, 0, x_132);
-lean_ctor_set(x_135, 1, x_133);
-return x_135;
+lean_ctor_set(x_136, 0, x_133);
+lean_ctor_set(x_136, 1, x_134);
+return x_136;
 }
 }
 else
 {
-lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; 
+lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
 lean_dec(x_3);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_136 = lean_ctor_get(x_81, 0);
-lean_inc(x_136);
-x_137 = lean_ctor_get(x_81, 1);
+x_137 = lean_ctor_get(x_82, 0);
 lean_inc(x_137);
-if (lean_is_exclusive(x_81)) {
- lean_ctor_release(x_81, 0);
- lean_ctor_release(x_81, 1);
- x_138 = x_81;
+x_138 = lean_ctor_get(x_82, 1);
+lean_inc(x_138);
+if (lean_is_exclusive(x_82)) {
+ lean_ctor_release(x_82, 0);
+ lean_ctor_release(x_82, 1);
+ x_139 = x_82;
 } else {
- lean_dec_ref(x_81);
- x_138 = lean_box(0);
+ lean_dec_ref(x_82);
+ x_139 = lean_box(0);
 }
-if (lean_is_scalar(x_138)) {
- x_139 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_139)) {
+ x_140 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_139 = x_138;
+ x_140 = x_139;
 }
-lean_ctor_set(x_139, 0, x_136);
-lean_ctor_set(x_139, 1, x_137);
-return x_139;
+lean_ctor_set(x_140, 0, x_137);
+lean_ctor_set(x_140, 1, x_138);
+return x_140;
 }
 }
 }
 else
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; uint8_t x_144; uint8_t x_145; uint8_t x_146; uint8_t x_147; uint8_t x_148; uint8_t x_149; uint8_t x_150; uint8_t x_151; lean_object* x_152; uint8_t x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; 
-x_140 = lean_ctor_get(x_3, 0);
-x_141 = lean_ctor_get(x_3, 1);
-x_142 = lean_ctor_get(x_3, 2);
-x_143 = lean_ctor_get(x_3, 3);
+lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; uint8_t x_145; uint8_t x_146; uint8_t x_147; uint8_t x_148; uint8_t x_149; uint8_t x_150; uint8_t x_151; uint8_t x_152; uint8_t x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; 
+x_141 = lean_ctor_get(x_3, 0);
+x_142 = lean_ctor_get(x_3, 1);
+x_143 = lean_ctor_get(x_3, 2);
+x_144 = lean_ctor_get(x_3, 3);
+lean_inc(x_144);
 lean_inc(x_143);
 lean_inc(x_142);
 lean_inc(x_141);
-lean_inc(x_140);
 lean_dec(x_3);
-x_144 = lean_ctor_get_uint8(x_140, 0);
-x_145 = lean_ctor_get_uint8(x_140, 1);
-x_146 = lean_ctor_get_uint8(x_140, 2);
-x_147 = lean_ctor_get_uint8(x_140, 3);
-x_148 = lean_ctor_get_uint8(x_140, 4);
-x_149 = lean_ctor_get_uint8(x_140, 6);
-x_150 = lean_ctor_get_uint8(x_140, 7);
-x_151 = lean_ctor_get_uint8(x_140, 8);
-if (lean_is_exclusive(x_140)) {
- x_152 = x_140;
+x_145 = lean_ctor_get_uint8(x_141, 0);
+x_146 = lean_ctor_get_uint8(x_141, 1);
+x_147 = lean_ctor_get_uint8(x_141, 2);
+x_148 = lean_ctor_get_uint8(x_141, 3);
+x_149 = lean_ctor_get_uint8(x_141, 4);
+x_150 = lean_ctor_get_uint8(x_141, 6);
+x_151 = lean_ctor_get_uint8(x_141, 7);
+x_152 = lean_ctor_get_uint8(x_141, 8);
+x_153 = lean_ctor_get_uint8(x_141, 9);
+if (lean_is_exclusive(x_141)) {
+ x_154 = x_141;
 } else {
- lean_dec_ref(x_140);
- x_152 = lean_box(0);
+ lean_dec_ref(x_141);
+ x_154 = lean_box(0);
 }
-x_153 = 2;
-if (lean_is_scalar(x_152)) {
- x_154 = lean_alloc_ctor(0, 0, 9);
+x_155 = 2;
+if (lean_is_scalar(x_154)) {
+ x_156 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_154 = x_152;
+ x_156 = x_154;
 }
-lean_ctor_set_uint8(x_154, 0, x_144);
-lean_ctor_set_uint8(x_154, 1, x_145);
-lean_ctor_set_uint8(x_154, 2, x_146);
-lean_ctor_set_uint8(x_154, 3, x_147);
-lean_ctor_set_uint8(x_154, 4, x_148);
-lean_ctor_set_uint8(x_154, 5, x_153);
-lean_ctor_set_uint8(x_154, 6, x_149);
-lean_ctor_set_uint8(x_154, 7, x_150);
-lean_ctor_set_uint8(x_154, 8, x_151);
-x_155 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_155, 0, x_154);
-lean_ctor_set(x_155, 1, x_141);
-lean_ctor_set(x_155, 2, x_142);
-lean_ctor_set(x_155, 3, x_143);
+lean_ctor_set_uint8(x_156, 0, x_145);
+lean_ctor_set_uint8(x_156, 1, x_146);
+lean_ctor_set_uint8(x_156, 2, x_147);
+lean_ctor_set_uint8(x_156, 3, x_148);
+lean_ctor_set_uint8(x_156, 4, x_149);
+lean_ctor_set_uint8(x_156, 5, x_155);
+lean_ctor_set_uint8(x_156, 6, x_150);
+lean_ctor_set_uint8(x_156, 7, x_151);
+lean_ctor_set_uint8(x_156, 8, x_152);
+lean_ctor_set_uint8(x_156, 9, x_153);
+x_157 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_157, 0, x_156);
+lean_ctor_set(x_157, 1, x_142);
+lean_ctor_set(x_157, 2, x_143);
+lean_ctor_set(x_157, 3, x_144);
 lean_inc(x_1);
-x_156 = l_Lean_mkConstWithLevelParams___at_Lean_Meta_mkCongrLemma___spec__1(x_1, x_155, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_156) == 0)
+x_158 = l_Lean_mkConstWithLevelParams___at_Lean_Meta_mkCongrLemma___spec__1(x_1, x_157, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_158) == 0)
 {
-lean_object* x_157; lean_object* x_158; lean_object* x_159; 
-x_157 = lean_ctor_get(x_156, 0);
-lean_inc(x_157);
-x_158 = lean_ctor_get(x_156, 1);
-lean_inc(x_158);
-lean_dec(x_156);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_155);
-lean_inc(x_157);
-x_159 = l_Lean_Meta_inferType(x_157, x_155, x_4, x_5, x_6, x_158);
-if (lean_obj_tag(x_159) == 0)
-{
-lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; uint8_t x_164; lean_object* x_165; 
-x_160 = lean_ctor_get(x_159, 0);
+lean_object* x_159; lean_object* x_160; lean_object* x_161; 
+x_159 = lean_ctor_get(x_158, 0);
+lean_inc(x_159);
+x_160 = lean_ctor_get(x_158, 1);
 lean_inc(x_160);
-x_161 = lean_ctor_get(x_159, 1);
-lean_inc(x_161);
-lean_dec(x_159);
-x_162 = lean_box(0);
-x_163 = 1;
-x_164 = 0;
+lean_dec(x_158);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_155);
-x_165 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_160, x_163, x_162, x_164, x_155, x_4, x_5, x_6, x_161);
-if (lean_obj_tag(x_165) == 0)
+lean_inc(x_157);
+lean_inc(x_159);
+x_161 = l_Lean_Meta_inferType(x_159, x_157, x_4, x_5, x_6, x_160);
+if (lean_obj_tag(x_161) == 0)
 {
-lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; 
-x_166 = lean_ctor_get(x_165, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_166, 1);
-lean_inc(x_167);
-x_168 = lean_ctor_get(x_165, 1);
+lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; uint8_t x_166; lean_object* x_167; 
+x_162 = lean_ctor_get(x_161, 0);
+lean_inc(x_162);
+x_163 = lean_ctor_get(x_161, 1);
+lean_inc(x_163);
+lean_dec(x_161);
+x_164 = lean_box(0);
+x_165 = 1;
+x_166 = 0;
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_157);
+x_167 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_162, x_165, x_164, x_166, x_157, x_4, x_5, x_6, x_163);
+if (lean_obj_tag(x_167) == 0)
+{
+lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; uint8_t x_176; 
+x_168 = lean_ctor_get(x_167, 0);
 lean_inc(x_168);
-lean_dec(x_165);
-x_169 = lean_ctor_get(x_166, 0);
+x_169 = lean_ctor_get(x_168, 1);
 lean_inc(x_169);
-lean_dec(x_166);
-x_170 = lean_ctor_get(x_167, 0);
+x_170 = lean_ctor_get(x_167, 1);
 lean_inc(x_170);
-x_171 = lean_ctor_get(x_167, 1);
-lean_inc(x_171);
 lean_dec(x_167);
-x_172 = l_myMacro____x40_Init_Notation___hyg_7553____closed__4;
-x_173 = lean_unsigned_to_nat(3u);
-x_174 = l_Lean_Expr_isAppOfArity(x_171, x_172, x_173);
-if (x_174 == 0)
-{
-lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; 
-lean_dec(x_170);
+x_171 = lean_ctor_get(x_168, 0);
+lean_inc(x_171);
+lean_dec(x_168);
+x_172 = lean_ctor_get(x_169, 0);
+lean_inc(x_172);
+x_173 = lean_ctor_get(x_169, 1);
+lean_inc(x_173);
 lean_dec(x_169);
-lean_dec(x_157);
+x_174 = l_myMacro____x40_Init_Notation___hyg_7553____closed__4;
+x_175 = lean_unsigned_to_nat(3u);
+x_176 = l_Lean_Expr_isAppOfArity(x_173, x_174, x_175);
+if (x_176 == 0)
+{
+lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; 
+lean_dec(x_172);
+lean_dec(x_171);
+lean_dec(x_159);
 lean_dec(x_2);
 lean_dec(x_1);
-x_175 = l_Lean_indentExpr(x_171);
-x_176 = l_Lean_Meta_mkCongrLemma___closed__2;
-x_177 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_177, 0, x_176);
-lean_ctor_set(x_177, 1, x_175);
-x_178 = l_Lean_KernelException_toMessageData___closed__15;
+x_177 = l_Lean_indentExpr(x_173);
+x_178 = l_Lean_Meta_mkCongrLemma___closed__2;
 x_179 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_179, 0, x_177);
-lean_ctor_set(x_179, 1, x_178);
-x_180 = l_Lean_throwError___at_Lean_Meta_mkCongrLemma___spec__2(x_179, x_155, x_4, x_5, x_6, x_168);
+lean_ctor_set(x_179, 0, x_178);
+lean_ctor_set(x_179, 1, x_177);
+x_180 = l_Lean_KernelException_toMessageData___closed__15;
+x_181 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_181, 0, x_179);
+lean_ctor_set(x_181, 1, x_180);
+x_182 = l_Lean_throwError___at_Lean_Meta_mkCongrLemma___spec__2(x_181, x_157, x_4, x_5, x_6, x_170);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-lean_dec(x_155);
-x_181 = lean_ctor_get(x_180, 0);
-lean_inc(x_181);
-x_182 = lean_ctor_get(x_180, 1);
-lean_inc(x_182);
-if (lean_is_exclusive(x_180)) {
- lean_ctor_release(x_180, 0);
- lean_ctor_release(x_180, 1);
- x_183 = x_180;
-} else {
- lean_dec_ref(x_180);
- x_183 = lean_box(0);
-}
-if (lean_is_scalar(x_183)) {
- x_184 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_184 = x_183;
-}
-lean_ctor_set(x_184, 0, x_181);
-lean_ctor_set(x_184, 1, x_182);
-return x_184;
-}
-else
-{
-lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; 
-x_185 = l_Lean_Expr_appFn_x21(x_171);
-x_186 = l_Lean_Expr_appArg_x21(x_185);
-lean_dec(x_185);
-x_187 = l_Lean_Expr_appArg_x21(x_171);
-x_188 = lean_unsigned_to_nat(0u);
-x_189 = l_Lean_Expr_getAppNumArgsAux(x_186, x_188);
-x_190 = l_Lean_Expr_getAppArgs___closed__1;
-lean_inc(x_189);
-x_191 = lean_mk_array(x_189, x_190);
-x_192 = lean_unsigned_to_nat(1u);
-x_193 = lean_nat_sub(x_189, x_192);
-lean_dec(x_189);
-lean_inc(x_186);
-x_194 = l_Lean_Expr_withAppAux___at_Lean_Meta_mkCongrLemma___spec__10(x_1, x_2, x_157, x_169, x_170, x_171, x_172, x_186, x_187, x_186, x_191, x_193, x_155, x_4, x_5, x_6, x_168);
-lean_dec(x_169);
-if (lean_obj_tag(x_194) == 0)
-{
-lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; 
-x_195 = lean_ctor_get(x_194, 0);
-lean_inc(x_195);
-x_196 = lean_ctor_get(x_194, 1);
-lean_inc(x_196);
-if (lean_is_exclusive(x_194)) {
- lean_ctor_release(x_194, 0);
- lean_ctor_release(x_194, 1);
- x_197 = x_194;
-} else {
- lean_dec_ref(x_194);
- x_197 = lean_box(0);
-}
-if (lean_is_scalar(x_197)) {
- x_198 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_198 = x_197;
-}
-lean_ctor_set(x_198, 0, x_195);
-lean_ctor_set(x_198, 1, x_196);
-return x_198;
-}
-else
-{
-lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; 
-x_199 = lean_ctor_get(x_194, 0);
-lean_inc(x_199);
-x_200 = lean_ctor_get(x_194, 1);
-lean_inc(x_200);
-if (lean_is_exclusive(x_194)) {
- lean_ctor_release(x_194, 0);
- lean_ctor_release(x_194, 1);
- x_201 = x_194;
-} else {
- lean_dec_ref(x_194);
- x_201 = lean_box(0);
-}
-if (lean_is_scalar(x_201)) {
- x_202 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_202 = x_201;
-}
-lean_ctor_set(x_202, 0, x_199);
-lean_ctor_set(x_202, 1, x_200);
-return x_202;
-}
-}
-}
-else
-{
-lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; 
 lean_dec(x_157);
-lean_dec(x_155);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_2);
-lean_dec(x_1);
-x_203 = lean_ctor_get(x_165, 0);
-lean_inc(x_203);
-x_204 = lean_ctor_get(x_165, 1);
-lean_inc(x_204);
-if (lean_is_exclusive(x_165)) {
- lean_ctor_release(x_165, 0);
- lean_ctor_release(x_165, 1);
- x_205 = x_165;
+x_183 = lean_ctor_get(x_182, 0);
+lean_inc(x_183);
+x_184 = lean_ctor_get(x_182, 1);
+lean_inc(x_184);
+if (lean_is_exclusive(x_182)) {
+ lean_ctor_release(x_182, 0);
+ lean_ctor_release(x_182, 1);
+ x_185 = x_182;
 } else {
- lean_dec_ref(x_165);
- x_205 = lean_box(0);
+ lean_dec_ref(x_182);
+ x_185 = lean_box(0);
 }
-if (lean_is_scalar(x_205)) {
- x_206 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_185)) {
+ x_186 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_206 = x_205;
+ x_186 = x_185;
+}
+lean_ctor_set(x_186, 0, x_183);
+lean_ctor_set(x_186, 1, x_184);
+return x_186;
+}
+else
+{
+lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; 
+x_187 = l_Lean_Expr_appFn_x21(x_173);
+x_188 = l_Lean_Expr_appArg_x21(x_187);
+lean_dec(x_187);
+x_189 = l_Lean_Expr_appArg_x21(x_173);
+x_190 = lean_unsigned_to_nat(0u);
+x_191 = l_Lean_Expr_getAppNumArgsAux(x_188, x_190);
+x_192 = l_Lean_Expr_getAppArgs___closed__1;
+lean_inc(x_191);
+x_193 = lean_mk_array(x_191, x_192);
+x_194 = lean_unsigned_to_nat(1u);
+x_195 = lean_nat_sub(x_191, x_194);
+lean_dec(x_191);
+lean_inc(x_188);
+x_196 = l_Lean_Expr_withAppAux___at_Lean_Meta_mkCongrLemma___spec__10(x_1, x_2, x_159, x_171, x_172, x_173, x_174, x_188, x_189, x_188, x_193, x_195, x_157, x_4, x_5, x_6, x_170);
+lean_dec(x_171);
+if (lean_obj_tag(x_196) == 0)
+{
+lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; 
+x_197 = lean_ctor_get(x_196, 0);
+lean_inc(x_197);
+x_198 = lean_ctor_get(x_196, 1);
+lean_inc(x_198);
+if (lean_is_exclusive(x_196)) {
+ lean_ctor_release(x_196, 0);
+ lean_ctor_release(x_196, 1);
+ x_199 = x_196;
+} else {
+ lean_dec_ref(x_196);
+ x_199 = lean_box(0);
+}
+if (lean_is_scalar(x_199)) {
+ x_200 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_200 = x_199;
+}
+lean_ctor_set(x_200, 0, x_197);
+lean_ctor_set(x_200, 1, x_198);
+return x_200;
+}
+else
+{
+lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; 
+x_201 = lean_ctor_get(x_196, 0);
+lean_inc(x_201);
+x_202 = lean_ctor_get(x_196, 1);
+lean_inc(x_202);
+if (lean_is_exclusive(x_196)) {
+ lean_ctor_release(x_196, 0);
+ lean_ctor_release(x_196, 1);
+ x_203 = x_196;
+} else {
+ lean_dec_ref(x_196);
+ x_203 = lean_box(0);
+}
+if (lean_is_scalar(x_203)) {
+ x_204 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_204 = x_203;
+}
+lean_ctor_set(x_204, 0, x_201);
+lean_ctor_set(x_204, 1, x_202);
+return x_204;
 }
-lean_ctor_set(x_206, 0, x_203);
-lean_ctor_set(x_206, 1, x_204);
-return x_206;
 }
 }
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; 
+lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; 
+lean_dec(x_159);
 lean_dec(x_157);
-lean_dec(x_155);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_207 = lean_ctor_get(x_159, 0);
-lean_inc(x_207);
-x_208 = lean_ctor_get(x_159, 1);
-lean_inc(x_208);
-if (lean_is_exclusive(x_159)) {
- lean_ctor_release(x_159, 0);
- lean_ctor_release(x_159, 1);
- x_209 = x_159;
+x_205 = lean_ctor_get(x_167, 0);
+lean_inc(x_205);
+x_206 = lean_ctor_get(x_167, 1);
+lean_inc(x_206);
+if (lean_is_exclusive(x_167)) {
+ lean_ctor_release(x_167, 0);
+ lean_ctor_release(x_167, 1);
+ x_207 = x_167;
 } else {
- lean_dec_ref(x_159);
- x_209 = lean_box(0);
+ lean_dec_ref(x_167);
+ x_207 = lean_box(0);
 }
-if (lean_is_scalar(x_209)) {
- x_210 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_207)) {
+ x_208 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_210 = x_209;
+ x_208 = x_207;
 }
-lean_ctor_set(x_210, 0, x_207);
-lean_ctor_set(x_210, 1, x_208);
-return x_210;
+lean_ctor_set(x_208, 0, x_205);
+lean_ctor_set(x_208, 1, x_206);
+return x_208;
 }
 }
 else
 {
-lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; 
-lean_dec(x_155);
+lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; 
+lean_dec(x_159);
+lean_dec(x_157);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_211 = lean_ctor_get(x_156, 0);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_156, 1);
-lean_inc(x_212);
-if (lean_is_exclusive(x_156)) {
- lean_ctor_release(x_156, 0);
- lean_ctor_release(x_156, 1);
- x_213 = x_156;
+x_209 = lean_ctor_get(x_161, 0);
+lean_inc(x_209);
+x_210 = lean_ctor_get(x_161, 1);
+lean_inc(x_210);
+if (lean_is_exclusive(x_161)) {
+ lean_ctor_release(x_161, 0);
+ lean_ctor_release(x_161, 1);
+ x_211 = x_161;
 } else {
- lean_dec_ref(x_156);
- x_213 = lean_box(0);
+ lean_dec_ref(x_161);
+ x_211 = lean_box(0);
 }
-if (lean_is_scalar(x_213)) {
- x_214 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_211)) {
+ x_212 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_214 = x_213;
+ x_212 = x_211;
 }
-lean_ctor_set(x_214, 0, x_211);
-lean_ctor_set(x_214, 1, x_212);
-return x_214;
+lean_ctor_set(x_212, 0, x_209);
+lean_ctor_set(x_212, 1, x_210);
+return x_212;
+}
+}
+else
+{
+lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; 
+lean_dec(x_157);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+lean_dec(x_1);
+x_213 = lean_ctor_get(x_158, 0);
+lean_inc(x_213);
+x_214 = lean_ctor_get(x_158, 1);
+lean_inc(x_214);
+if (lean_is_exclusive(x_158)) {
+ lean_ctor_release(x_158, 0);
+ lean_ctor_release(x_158, 1);
+ x_215 = x_158;
+} else {
+ lean_dec_ref(x_158);
+ x_215 = lean_box(0);
+}
+if (lean_is_scalar(x_215)) {
+ x_216 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_216 = x_215;
+}
+lean_ctor_set(x_216, 0, x_213);
+lean_ctor_set(x_216, 1, x_214);
+return x_216;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Simp/Main.c b/stage0/stdlib/Lean/Meta/Tactic/Simp/Main.c
index ec7fd9b088..898f98b194 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Simp/Main.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Simp/Main.c
@@ -2910,7 +2910,7 @@ return x_111;
 }
 else
 {
-uint8_t x_112; uint8_t x_113; uint8_t x_114; uint8_t x_115; uint8_t x_116; uint8_t x_117; uint8_t x_118; uint8_t x_119; uint8_t x_120; lean_object* x_121; lean_object* x_122; 
+uint8_t x_112; uint8_t x_113; uint8_t x_114; uint8_t x_115; uint8_t x_116; uint8_t x_117; uint8_t x_118; uint8_t x_119; uint8_t x_120; uint8_t x_121; lean_object* x_122; lean_object* x_123; 
 x_112 = lean_ctor_get_uint8(x_100, 0);
 x_113 = lean_ctor_get_uint8(x_100, 1);
 x_114 = lean_ctor_get_uint8(x_100, 2);
@@ -2919,712 +2919,696 @@ x_116 = lean_ctor_get_uint8(x_100, 4);
 x_117 = lean_ctor_get_uint8(x_100, 6);
 x_118 = lean_ctor_get_uint8(x_100, 7);
 x_119 = lean_ctor_get_uint8(x_100, 8);
+x_120 = lean_ctor_get_uint8(x_100, 9);
 lean_dec(x_100);
-x_120 = 3;
-x_121 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_121, 0, x_112);
-lean_ctor_set_uint8(x_121, 1, x_113);
-lean_ctor_set_uint8(x_121, 2, x_114);
-lean_ctor_set_uint8(x_121, 3, x_115);
-lean_ctor_set_uint8(x_121, 4, x_116);
-lean_ctor_set_uint8(x_121, 5, x_120);
-lean_ctor_set_uint8(x_121, 6, x_117);
-lean_ctor_set_uint8(x_121, 7, x_118);
-lean_ctor_set_uint8(x_121, 8, x_119);
-lean_ctor_set(x_4, 0, x_121);
-x_122 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_4, x_5, x_6, x_7, x_94);
-if (lean_obj_tag(x_122) == 0)
+x_121 = 3;
+x_122 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_122, 0, x_112);
+lean_ctor_set_uint8(x_122, 1, x_113);
+lean_ctor_set_uint8(x_122, 2, x_114);
+lean_ctor_set_uint8(x_122, 3, x_115);
+lean_ctor_set_uint8(x_122, 4, x_116);
+lean_ctor_set_uint8(x_122, 5, x_121);
+lean_ctor_set_uint8(x_122, 6, x_117);
+lean_ctor_set_uint8(x_122, 7, x_118);
+lean_ctor_set_uint8(x_122, 8, x_119);
+lean_ctor_set_uint8(x_122, 9, x_120);
+lean_ctor_set(x_4, 0, x_122);
+x_123 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_4, x_5, x_6, x_7, x_94);
+if (lean_obj_tag(x_123) == 0)
 {
-lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; 
-x_123 = lean_ctor_get(x_122, 0);
-lean_inc(x_123);
-x_124 = lean_ctor_get(x_122, 1);
+lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; 
+x_124 = lean_ctor_get(x_123, 0);
 lean_inc(x_124);
-if (lean_is_exclusive(x_122)) {
- lean_ctor_release(x_122, 0);
- lean_ctor_release(x_122, 1);
- x_125 = x_122;
+x_125 = lean_ctor_get(x_123, 1);
+lean_inc(x_125);
+if (lean_is_exclusive(x_123)) {
+ lean_ctor_release(x_123, 0);
+ lean_ctor_release(x_123, 1);
+ x_126 = x_123;
 } else {
- lean_dec_ref(x_122);
- x_125 = lean_box(0);
+ lean_dec_ref(x_123);
+ x_126 = lean_box(0);
 }
-if (lean_is_scalar(x_125)) {
- x_126 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_126)) {
+ x_127 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_126 = x_125;
+ x_127 = x_126;
 }
-lean_ctor_set(x_126, 0, x_123);
-lean_ctor_set(x_126, 1, x_124);
-return x_126;
+lean_ctor_set(x_127, 0, x_124);
+lean_ctor_set(x_127, 1, x_125);
+return x_127;
 }
 else
 {
-lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; 
-x_127 = lean_ctor_get(x_122, 0);
-lean_inc(x_127);
-x_128 = lean_ctor_get(x_122, 1);
+lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; 
+x_128 = lean_ctor_get(x_123, 0);
 lean_inc(x_128);
-if (lean_is_exclusive(x_122)) {
- lean_ctor_release(x_122, 0);
- lean_ctor_release(x_122, 1);
- x_129 = x_122;
+x_129 = lean_ctor_get(x_123, 1);
+lean_inc(x_129);
+if (lean_is_exclusive(x_123)) {
+ lean_ctor_release(x_123, 0);
+ lean_ctor_release(x_123, 1);
+ x_130 = x_123;
 } else {
- lean_dec_ref(x_122);
- x_129 = lean_box(0);
+ lean_dec_ref(x_123);
+ x_130 = lean_box(0);
 }
-if (lean_is_scalar(x_129)) {
- x_130 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_130)) {
+ x_131 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_130 = x_129;
+ x_131 = x_130;
 }
-lean_ctor_set(x_130, 0, x_127);
-lean_ctor_set(x_130, 1, x_128);
-return x_130;
+lean_ctor_set(x_131, 0, x_128);
+lean_ctor_set(x_131, 1, x_129);
+return x_131;
 }
 }
 }
 else
 {
-lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; uint8_t x_135; uint8_t x_136; uint8_t x_137; uint8_t x_138; uint8_t x_139; uint8_t x_140; uint8_t x_141; uint8_t x_142; lean_object* x_143; uint8_t x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; 
-x_131 = lean_ctor_get(x_4, 0);
-x_132 = lean_ctor_get(x_4, 1);
-x_133 = lean_ctor_get(x_4, 2);
-x_134 = lean_ctor_get(x_4, 3);
+lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; uint8_t x_137; uint8_t x_138; uint8_t x_139; uint8_t x_140; uint8_t x_141; uint8_t x_142; uint8_t x_143; uint8_t x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; 
+x_132 = lean_ctor_get(x_4, 0);
+x_133 = lean_ctor_get(x_4, 1);
+x_134 = lean_ctor_get(x_4, 2);
+x_135 = lean_ctor_get(x_4, 3);
+lean_inc(x_135);
 lean_inc(x_134);
 lean_inc(x_133);
 lean_inc(x_132);
-lean_inc(x_131);
 lean_dec(x_4);
-x_135 = lean_ctor_get_uint8(x_131, 0);
-x_136 = lean_ctor_get_uint8(x_131, 1);
-x_137 = lean_ctor_get_uint8(x_131, 2);
-x_138 = lean_ctor_get_uint8(x_131, 3);
-x_139 = lean_ctor_get_uint8(x_131, 4);
-x_140 = lean_ctor_get_uint8(x_131, 6);
-x_141 = lean_ctor_get_uint8(x_131, 7);
-x_142 = lean_ctor_get_uint8(x_131, 8);
-if (lean_is_exclusive(x_131)) {
- x_143 = x_131;
+x_136 = lean_ctor_get_uint8(x_132, 0);
+x_137 = lean_ctor_get_uint8(x_132, 1);
+x_138 = lean_ctor_get_uint8(x_132, 2);
+x_139 = lean_ctor_get_uint8(x_132, 3);
+x_140 = lean_ctor_get_uint8(x_132, 4);
+x_141 = lean_ctor_get_uint8(x_132, 6);
+x_142 = lean_ctor_get_uint8(x_132, 7);
+x_143 = lean_ctor_get_uint8(x_132, 8);
+x_144 = lean_ctor_get_uint8(x_132, 9);
+if (lean_is_exclusive(x_132)) {
+ x_145 = x_132;
 } else {
- lean_dec_ref(x_131);
- x_143 = lean_box(0);
+ lean_dec_ref(x_132);
+ x_145 = lean_box(0);
 }
-x_144 = 3;
-if (lean_is_scalar(x_143)) {
- x_145 = lean_alloc_ctor(0, 0, 9);
+x_146 = 3;
+if (lean_is_scalar(x_145)) {
+ x_147 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_145 = x_143;
+ x_147 = x_145;
 }
-lean_ctor_set_uint8(x_145, 0, x_135);
-lean_ctor_set_uint8(x_145, 1, x_136);
-lean_ctor_set_uint8(x_145, 2, x_137);
-lean_ctor_set_uint8(x_145, 3, x_138);
-lean_ctor_set_uint8(x_145, 4, x_139);
-lean_ctor_set_uint8(x_145, 5, x_144);
-lean_ctor_set_uint8(x_145, 6, x_140);
-lean_ctor_set_uint8(x_145, 7, x_141);
-lean_ctor_set_uint8(x_145, 8, x_142);
-x_146 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_146, 0, x_145);
-lean_ctor_set(x_146, 1, x_132);
-lean_ctor_set(x_146, 2, x_133);
-lean_ctor_set(x_146, 3, x_134);
-x_147 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_146, x_5, x_6, x_7, x_94);
-if (lean_obj_tag(x_147) == 0)
+lean_ctor_set_uint8(x_147, 0, x_136);
+lean_ctor_set_uint8(x_147, 1, x_137);
+lean_ctor_set_uint8(x_147, 2, x_138);
+lean_ctor_set_uint8(x_147, 3, x_139);
+lean_ctor_set_uint8(x_147, 4, x_140);
+lean_ctor_set_uint8(x_147, 5, x_146);
+lean_ctor_set_uint8(x_147, 6, x_141);
+lean_ctor_set_uint8(x_147, 7, x_142);
+lean_ctor_set_uint8(x_147, 8, x_143);
+lean_ctor_set_uint8(x_147, 9, x_144);
+x_148 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_148, 0, x_147);
+lean_ctor_set(x_148, 1, x_133);
+lean_ctor_set(x_148, 2, x_134);
+lean_ctor_set(x_148, 3, x_135);
+x_149 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_148, x_5, x_6, x_7, x_94);
+if (lean_obj_tag(x_149) == 0)
 {
-lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
-x_148 = lean_ctor_get(x_147, 0);
-lean_inc(x_148);
-x_149 = lean_ctor_get(x_147, 1);
-lean_inc(x_149);
-if (lean_is_exclusive(x_147)) {
- lean_ctor_release(x_147, 0);
- lean_ctor_release(x_147, 1);
- x_150 = x_147;
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; 
+x_150 = lean_ctor_get(x_149, 0);
+lean_inc(x_150);
+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_147);
- x_150 = lean_box(0);
+ lean_dec_ref(x_149);
+ x_152 = lean_box(0);
 }
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_152)) {
+ x_153 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_151 = x_150;
+ x_153 = x_152;
 }
-lean_ctor_set(x_151, 0, x_148);
-lean_ctor_set(x_151, 1, x_149);
-return x_151;
+lean_ctor_set(x_153, 0, x_150);
+lean_ctor_set(x_153, 1, x_151);
+return x_153;
 }
 else
 {
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; 
-x_152 = lean_ctor_get(x_147, 0);
-lean_inc(x_152);
-x_153 = lean_ctor_get(x_147, 1);
-lean_inc(x_153);
-if (lean_is_exclusive(x_147)) {
- lean_ctor_release(x_147, 0);
- lean_ctor_release(x_147, 1);
- x_154 = x_147;
+lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; 
+x_154 = lean_ctor_get(x_149, 0);
+lean_inc(x_154);
+x_155 = lean_ctor_get(x_149, 1);
+lean_inc(x_155);
+if (lean_is_exclusive(x_149)) {
+ lean_ctor_release(x_149, 0);
+ lean_ctor_release(x_149, 1);
+ x_156 = x_149;
 } else {
- lean_dec_ref(x_147);
- x_154 = lean_box(0);
+ lean_dec_ref(x_149);
+ x_156 = lean_box(0);
 }
-if (lean_is_scalar(x_154)) {
- x_155 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_156)) {
+ x_157 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_155 = x_154;
+ x_157 = x_156;
 }
-lean_ctor_set(x_155, 0, x_152);
-lean_ctor_set(x_155, 1, x_153);
-return x_155;
+lean_ctor_set(x_157, 0, x_154);
+lean_ctor_set(x_157, 1, x_155);
+return x_157;
 }
 }
 }
 }
 else
 {
-lean_object* x_156; lean_object* x_157; uint8_t x_158; 
-x_156 = lean_ctor_get(x_20, 1);
-lean_inc(x_156);
+lean_object* x_158; lean_object* x_159; uint8_t x_160; 
+x_158 = lean_ctor_get(x_20, 1);
+lean_inc(x_158);
 lean_dec(x_20);
-x_157 = lean_ctor_get(x_2, 1);
-lean_inc(x_157);
+x_159 = lean_ctor_get(x_2, 1);
+lean_inc(x_159);
 lean_dec(x_2);
-x_158 = l_Lean_Meta_SimpLemmas_isDeclToUnfold(x_157, x_19);
+x_160 = l_Lean_Meta_SimpLemmas_isDeclToUnfold(x_159, x_19);
 lean_dec(x_19);
-if (x_158 == 0)
+if (x_160 == 0)
 {
-lean_object* x_159; lean_object* x_160; 
+lean_object* x_161; lean_object* x_162; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_159 = lean_box(0);
-x_160 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_160, 0, x_159);
-lean_ctor_set(x_160, 1, x_156);
-return x_160;
+x_161 = lean_box(0);
+x_162 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_162, 0, x_161);
+lean_ctor_set(x_162, 1, x_158);
+return x_162;
 }
 else
 {
-lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; uint8_t x_166; uint8_t x_167; uint8_t x_168; uint8_t x_169; uint8_t x_170; uint8_t x_171; uint8_t x_172; uint8_t x_173; lean_object* x_174; uint8_t x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; 
-x_161 = lean_ctor_get(x_4, 0);
-lean_inc(x_161);
-x_162 = lean_ctor_get(x_4, 1);
-lean_inc(x_162);
-x_163 = lean_ctor_get(x_4, 2);
+lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; uint8_t x_168; uint8_t x_169; uint8_t x_170; uint8_t x_171; uint8_t x_172; uint8_t x_173; uint8_t x_174; uint8_t x_175; uint8_t x_176; lean_object* x_177; uint8_t x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; 
+x_163 = lean_ctor_get(x_4, 0);
 lean_inc(x_163);
-x_164 = lean_ctor_get(x_4, 3);
+x_164 = lean_ctor_get(x_4, 1);
 lean_inc(x_164);
+x_165 = lean_ctor_get(x_4, 2);
+lean_inc(x_165);
+x_166 = lean_ctor_get(x_4, 3);
+lean_inc(x_166);
 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);
- x_165 = x_4;
+ x_167 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_165 = lean_box(0);
+ x_167 = lean_box(0);
 }
-x_166 = lean_ctor_get_uint8(x_161, 0);
-x_167 = lean_ctor_get_uint8(x_161, 1);
-x_168 = lean_ctor_get_uint8(x_161, 2);
-x_169 = lean_ctor_get_uint8(x_161, 3);
-x_170 = lean_ctor_get_uint8(x_161, 4);
-x_171 = lean_ctor_get_uint8(x_161, 6);
-x_172 = lean_ctor_get_uint8(x_161, 7);
-x_173 = lean_ctor_get_uint8(x_161, 8);
-if (lean_is_exclusive(x_161)) {
- x_174 = x_161;
+x_168 = lean_ctor_get_uint8(x_163, 0);
+x_169 = lean_ctor_get_uint8(x_163, 1);
+x_170 = lean_ctor_get_uint8(x_163, 2);
+x_171 = lean_ctor_get_uint8(x_163, 3);
+x_172 = lean_ctor_get_uint8(x_163, 4);
+x_173 = lean_ctor_get_uint8(x_163, 6);
+x_174 = lean_ctor_get_uint8(x_163, 7);
+x_175 = lean_ctor_get_uint8(x_163, 8);
+x_176 = lean_ctor_get_uint8(x_163, 9);
+if (lean_is_exclusive(x_163)) {
+ x_177 = x_163;
 } else {
- lean_dec_ref(x_161);
- x_174 = lean_box(0);
+ lean_dec_ref(x_163);
+ x_177 = lean_box(0);
 }
-x_175 = 3;
-if (lean_is_scalar(x_174)) {
- x_176 = lean_alloc_ctor(0, 0, 9);
+x_178 = 3;
+if (lean_is_scalar(x_177)) {
+ x_179 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_176 = x_174;
+ x_179 = x_177;
 }
-lean_ctor_set_uint8(x_176, 0, x_166);
-lean_ctor_set_uint8(x_176, 1, x_167);
-lean_ctor_set_uint8(x_176, 2, x_168);
-lean_ctor_set_uint8(x_176, 3, x_169);
-lean_ctor_set_uint8(x_176, 4, x_170);
-lean_ctor_set_uint8(x_176, 5, x_175);
-lean_ctor_set_uint8(x_176, 6, x_171);
-lean_ctor_set_uint8(x_176, 7, x_172);
-lean_ctor_set_uint8(x_176, 8, x_173);
-if (lean_is_scalar(x_165)) {
- x_177 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set_uint8(x_179, 0, x_168);
+lean_ctor_set_uint8(x_179, 1, x_169);
+lean_ctor_set_uint8(x_179, 2, x_170);
+lean_ctor_set_uint8(x_179, 3, x_171);
+lean_ctor_set_uint8(x_179, 4, x_172);
+lean_ctor_set_uint8(x_179, 5, x_178);
+lean_ctor_set_uint8(x_179, 6, x_173);
+lean_ctor_set_uint8(x_179, 7, x_174);
+lean_ctor_set_uint8(x_179, 8, x_175);
+lean_ctor_set_uint8(x_179, 9, x_176);
+if (lean_is_scalar(x_167)) {
+ x_180 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_177 = x_165;
+ x_180 = x_167;
 }
-lean_ctor_set(x_177, 0, x_176);
-lean_ctor_set(x_177, 1, x_162);
-lean_ctor_set(x_177, 2, x_163);
-lean_ctor_set(x_177, 3, x_164);
-x_178 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_177, x_5, x_6, x_7, x_156);
-if (lean_obj_tag(x_178) == 0)
+lean_ctor_set(x_180, 0, x_179);
+lean_ctor_set(x_180, 1, x_164);
+lean_ctor_set(x_180, 2, x_165);
+lean_ctor_set(x_180, 3, x_166);
+x_181 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_180, x_5, x_6, x_7, x_158);
+if (lean_obj_tag(x_181) == 0)
 {
-lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; 
-x_179 = lean_ctor_get(x_178, 0);
-lean_inc(x_179);
-x_180 = lean_ctor_get(x_178, 1);
-lean_inc(x_180);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- x_181 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_181 = lean_box(0);
-}
-if (lean_is_scalar(x_181)) {
- x_182 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_182 = x_181;
-}
-lean_ctor_set(x_182, 0, x_179);
-lean_ctor_set(x_182, 1, x_180);
-return x_182;
-}
-else
-{
-lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; 
-x_183 = lean_ctor_get(x_178, 0);
+lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; 
+x_182 = lean_ctor_get(x_181, 0);
+lean_inc(x_182);
+x_183 = lean_ctor_get(x_181, 1);
 lean_inc(x_183);
-x_184 = lean_ctor_get(x_178, 1);
-lean_inc(x_184);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- x_185 = x_178;
+if (lean_is_exclusive(x_181)) {
+ lean_ctor_release(x_181, 0);
+ lean_ctor_release(x_181, 1);
+ x_184 = x_181;
 } else {
- lean_dec_ref(x_178);
- x_185 = lean_box(0);
+ lean_dec_ref(x_181);
+ x_184 = lean_box(0);
 }
-if (lean_is_scalar(x_185)) {
- x_186 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_184)) {
+ x_185 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_186 = x_185;
-}
-lean_ctor_set(x_186, 0, x_183);
-lean_ctor_set(x_186, 1, x_184);
-return x_186;
-}
-}
-}
-}
-}
+ x_185 = x_184;
 }
+lean_ctor_set(x_185, 0, x_182);
+lean_ctor_set(x_185, 1, x_183);
+return x_185;
 }
 else
 {
-lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; 
-x_187 = lean_ctor_get(x_11, 0);
-x_188 = lean_ctor_get(x_11, 1);
-lean_inc(x_188);
+lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; 
+x_186 = lean_ctor_get(x_181, 0);
+lean_inc(x_186);
+x_187 = lean_ctor_get(x_181, 1);
 lean_inc(x_187);
+if (lean_is_exclusive(x_181)) {
+ lean_ctor_release(x_181, 0);
+ lean_ctor_release(x_181, 1);
+ x_188 = x_181;
+} else {
+ lean_dec_ref(x_181);
+ x_188 = lean_box(0);
+}
+if (lean_is_scalar(x_188)) {
+ x_189 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_189 = x_188;
+}
+lean_ctor_set(x_189, 0, x_186);
+lean_ctor_set(x_189, 1, x_187);
+return x_189;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; 
+x_190 = lean_ctor_get(x_11, 0);
+x_191 = lean_ctor_get(x_11, 1);
+lean_inc(x_191);
+lean_inc(x_190);
 lean_dec(x_11);
-x_189 = lean_ctor_get(x_187, 0);
-lean_inc(x_189);
-lean_dec(x_187);
-x_190 = lean_environment_find(x_189, x_10);
-if (lean_obj_tag(x_190) == 0)
-{
-lean_object* x_191; lean_object* x_192; 
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_2);
-lean_dec(x_1);
-x_191 = lean_box(0);
-x_192 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_192, 0, x_191);
-lean_ctor_set(x_192, 1, x_188);
-return x_192;
-}
-else
-{
-lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; 
-x_193 = lean_ctor_get(x_190, 0);
-lean_inc(x_193);
+x_192 = lean_ctor_get(x_190, 0);
+lean_inc(x_192);
 lean_dec(x_190);
-x_194 = l_Lean_ConstantInfo_name(x_193);
-lean_dec(x_193);
-lean_inc(x_194);
-x_195 = l_Lean_getProjectionFnInfo_x3f___at___private_Lean_Meta_Tactic_Simp_Main_0__Lean_Meta_Simp_reduceProjFn_x3f___spec__1(x_194, x_2, x_3, x_4, x_5, x_6, x_7, x_188);
-x_196 = lean_ctor_get(x_195, 0);
-lean_inc(x_196);
-if (lean_obj_tag(x_196) == 0)
+x_193 = lean_environment_find(x_192, x_10);
+if (lean_obj_tag(x_193) == 0)
 {
-lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; 
-lean_dec(x_194);
+lean_object* x_194; lean_object* x_195; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_197 = lean_ctor_get(x_195, 1);
-lean_inc(x_197);
-if (lean_is_exclusive(x_195)) {
- lean_ctor_release(x_195, 0);
- lean_ctor_release(x_195, 1);
- x_198 = x_195;
-} else {
- lean_dec_ref(x_195);
- x_198 = lean_box(0);
-}
-x_199 = lean_box(0);
-if (lean_is_scalar(x_198)) {
- x_200 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_200 = x_198;
-}
-lean_ctor_set(x_200, 0, x_199);
-lean_ctor_set(x_200, 1, x_197);
-return x_200;
+x_194 = lean_box(0);
+x_195 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_195, 0, x_194);
+lean_ctor_set(x_195, 1, x_191);
+return x_195;
 }
 else
 {
-lean_object* x_201; uint8_t x_202; 
-x_201 = lean_ctor_get(x_196, 0);
-lean_inc(x_201);
+lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; 
+x_196 = lean_ctor_get(x_193, 0);
+lean_inc(x_196);
+lean_dec(x_193);
+x_197 = l_Lean_ConstantInfo_name(x_196);
 lean_dec(x_196);
-x_202 = lean_ctor_get_uint8(x_201, sizeof(void*)*3);
-lean_dec(x_201);
-if (x_202 == 0)
+lean_inc(x_197);
+x_198 = l_Lean_getProjectionFnInfo_x3f___at___private_Lean_Meta_Tactic_Simp_Main_0__Lean_Meta_Simp_reduceProjFn_x3f___spec__1(x_197, x_2, x_3, x_4, x_5, x_6, x_7, x_191);
+x_199 = lean_ctor_get(x_198, 0);
+lean_inc(x_199);
+if (lean_obj_tag(x_199) == 0)
 {
-lean_object* x_203; lean_object* x_204; 
-lean_dec(x_194);
+lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; 
+lean_dec(x_197);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_2);
-x_203 = lean_ctor_get(x_195, 1);
-lean_inc(x_203);
-lean_dec(x_195);
+lean_dec(x_1);
+x_200 = lean_ctor_get(x_198, 1);
+lean_inc(x_200);
+if (lean_is_exclusive(x_198)) {
+ lean_ctor_release(x_198, 0);
+ lean_ctor_release(x_198, 1);
+ x_201 = x_198;
+} else {
+ lean_dec_ref(x_198);
+ x_201 = lean_box(0);
+}
+x_202 = lean_box(0);
+if (lean_is_scalar(x_201)) {
+ x_203 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_203 = x_201;
+}
+lean_ctor_set(x_203, 0, x_202);
+lean_ctor_set(x_203, 1, x_200);
+return x_203;
+}
+else
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = lean_ctor_get(x_199, 0);
+lean_inc(x_204);
+lean_dec(x_199);
+x_205 = lean_ctor_get_uint8(x_204, sizeof(void*)*3);
+lean_dec(x_204);
+if (x_205 == 0)
+{
+lean_object* x_206; lean_object* x_207; 
+lean_dec(x_197);
+lean_dec(x_2);
+x_206 = lean_ctor_get(x_198, 1);
+lean_inc(x_206);
+lean_dec(x_198);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_204 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_4, x_5, x_6, x_7, x_203);
-if (lean_obj_tag(x_204) == 0)
+x_207 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_4, x_5, x_6, x_7, x_206);
+if (lean_obj_tag(x_207) == 0)
 {
-lean_object* x_205; 
-x_205 = lean_ctor_get(x_204, 0);
-lean_inc(x_205);
-if (lean_obj_tag(x_205) == 0)
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_207, 0);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
 {
-lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; 
+lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_206 = lean_ctor_get(x_204, 1);
-lean_inc(x_206);
-if (lean_is_exclusive(x_204)) {
- lean_ctor_release(x_204, 0);
- lean_ctor_release(x_204, 1);
- x_207 = x_204;
+x_209 = lean_ctor_get(x_207, 1);
+lean_inc(x_209);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ x_210 = x_207;
 } else {
- lean_dec_ref(x_204);
- x_207 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_210 = lean_box(0);
 }
-x_208 = lean_box(0);
-if (lean_is_scalar(x_207)) {
- x_209 = lean_alloc_ctor(0, 2, 0);
+x_211 = lean_box(0);
+if (lean_is_scalar(x_210)) {
+ x_212 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_209 = x_207;
+ x_212 = x_210;
 }
-lean_ctor_set(x_209, 0, x_208);
-lean_ctor_set(x_209, 1, x_206);
-return x_209;
+lean_ctor_set(x_212, 0, x_211);
+lean_ctor_set(x_212, 1, x_209);
+return x_212;
 }
 else
 {
-lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; 
-x_210 = lean_ctor_get(x_204, 1);
-lean_inc(x_210);
-lean_dec(x_204);
-x_211 = lean_ctor_get(x_205, 0);
-lean_inc(x_211);
-lean_dec(x_205);
-x_212 = l_Lean_Expr_getAppFn(x_211);
-x_213 = l_Lean_Meta_reduceProj_x3f(x_212, x_4, x_5, x_6, x_7, x_210);
-if (lean_obj_tag(x_213) == 0)
-{
-lean_object* x_214; 
-x_214 = lean_ctor_get(x_213, 0);
+lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; 
+x_213 = lean_ctor_get(x_207, 1);
+lean_inc(x_213);
+lean_dec(x_207);
+x_214 = lean_ctor_get(x_208, 0);
 lean_inc(x_214);
-if (lean_obj_tag(x_214) == 0)
+lean_dec(x_208);
+x_215 = l_Lean_Expr_getAppFn(x_214);
+x_216 = l_Lean_Meta_reduceProj_x3f(x_215, x_4, x_5, x_6, x_7, x_213);
+if (lean_obj_tag(x_216) == 0)
 {
-lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; 
-lean_dec(x_211);
-x_215 = lean_ctor_get(x_213, 1);
-lean_inc(x_215);
-if (lean_is_exclusive(x_213)) {
- lean_ctor_release(x_213, 0);
- lean_ctor_release(x_213, 1);
- x_216 = x_213;
+lean_object* x_217; 
+x_217 = lean_ctor_get(x_216, 0);
+lean_inc(x_217);
+if (lean_obj_tag(x_217) == 0)
+{
+lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; 
+lean_dec(x_214);
+x_218 = lean_ctor_get(x_216, 1);
+lean_inc(x_218);
+if (lean_is_exclusive(x_216)) {
+ lean_ctor_release(x_216, 0);
+ lean_ctor_release(x_216, 1);
+ x_219 = x_216;
 } else {
- lean_dec_ref(x_213);
- x_216 = lean_box(0);
+ lean_dec_ref(x_216);
+ x_219 = lean_box(0);
 }
-x_217 = lean_box(0);
-if (lean_is_scalar(x_216)) {
- x_218 = lean_alloc_ctor(0, 2, 0);
+x_220 = lean_box(0);
+if (lean_is_scalar(x_219)) {
+ x_221 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_218 = x_216;
+ x_221 = x_219;
 }
-lean_ctor_set(x_218, 0, x_217);
-lean_ctor_set(x_218, 1, x_215);
-return x_218;
+lean_ctor_set(x_221, 0, x_220);
+lean_ctor_set(x_221, 1, x_218);
+return x_221;
 }
 else
 {
-lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; 
-x_219 = lean_ctor_get(x_213, 1);
-lean_inc(x_219);
-if (lean_is_exclusive(x_213)) {
- lean_ctor_release(x_213, 0);
- lean_ctor_release(x_213, 1);
- x_220 = x_213;
+lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; 
+x_222 = lean_ctor_get(x_216, 1);
+lean_inc(x_222);
+if (lean_is_exclusive(x_216)) {
+ lean_ctor_release(x_216, 0);
+ lean_ctor_release(x_216, 1);
+ x_223 = x_216;
 } else {
- lean_dec_ref(x_213);
- x_220 = lean_box(0);
+ lean_dec_ref(x_216);
+ x_223 = lean_box(0);
 }
-x_221 = lean_ctor_get(x_214, 0);
-lean_inc(x_221);
-if (lean_is_exclusive(x_214)) {
- lean_ctor_release(x_214, 0);
- x_222 = x_214;
-} else {
- lean_dec_ref(x_214);
- x_222 = lean_box(0);
-}
-x_223 = lean_unsigned_to_nat(0u);
-x_224 = l_Lean_Expr_getAppNumArgsAux(x_211, x_223);
-x_225 = l_Lean_Expr_getAppArgs___closed__1;
+x_224 = lean_ctor_get(x_217, 0);
 lean_inc(x_224);
-x_226 = lean_mk_array(x_224, x_225);
-x_227 = lean_unsigned_to_nat(1u);
-x_228 = lean_nat_sub(x_224, x_227);
-lean_dec(x_224);
-x_229 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_211, x_226, x_228);
-x_230 = l_Lean_mkAppN(x_221, x_229);
-lean_dec(x_229);
-if (lean_is_scalar(x_222)) {
- x_231 = lean_alloc_ctor(1, 1, 0);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ x_225 = x_217;
 } else {
- x_231 = x_222;
+ lean_dec_ref(x_217);
+ x_225 = lean_box(0);
 }
-lean_ctor_set(x_231, 0, x_230);
-if (lean_is_scalar(x_220)) {
- x_232 = lean_alloc_ctor(0, 2, 0);
+x_226 = lean_unsigned_to_nat(0u);
+x_227 = l_Lean_Expr_getAppNumArgsAux(x_214, x_226);
+x_228 = l_Lean_Expr_getAppArgs___closed__1;
+lean_inc(x_227);
+x_229 = lean_mk_array(x_227, x_228);
+x_230 = lean_unsigned_to_nat(1u);
+x_231 = lean_nat_sub(x_227, x_230);
+lean_dec(x_227);
+x_232 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_214, x_229, x_231);
+x_233 = l_Lean_mkAppN(x_224, x_232);
+lean_dec(x_232);
+if (lean_is_scalar(x_225)) {
+ x_234 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_232 = x_220;
+ x_234 = x_225;
 }
-lean_ctor_set(x_232, 0, x_231);
-lean_ctor_set(x_232, 1, x_219);
-return x_232;
+lean_ctor_set(x_234, 0, x_233);
+if (lean_is_scalar(x_223)) {
+ x_235 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_235 = x_223;
+}
+lean_ctor_set(x_235, 0, x_234);
+lean_ctor_set(x_235, 1, x_222);
+return x_235;
 }
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; 
-lean_dec(x_211);
-x_233 = lean_ctor_get(x_213, 0);
-lean_inc(x_233);
-x_234 = lean_ctor_get(x_213, 1);
-lean_inc(x_234);
-if (lean_is_exclusive(x_213)) {
- lean_ctor_release(x_213, 0);
- lean_ctor_release(x_213, 1);
- x_235 = x_213;
+lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; 
+lean_dec(x_214);
+x_236 = lean_ctor_get(x_216, 0);
+lean_inc(x_236);
+x_237 = lean_ctor_get(x_216, 1);
+lean_inc(x_237);
+if (lean_is_exclusive(x_216)) {
+ lean_ctor_release(x_216, 0);
+ lean_ctor_release(x_216, 1);
+ x_238 = x_216;
 } else {
- lean_dec_ref(x_213);
- x_235 = lean_box(0);
+ lean_dec_ref(x_216);
+ x_238 = lean_box(0);
 }
-if (lean_is_scalar(x_235)) {
- x_236 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_238)) {
+ x_239 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_236 = x_235;
+ x_239 = x_238;
 }
-lean_ctor_set(x_236, 0, x_233);
-lean_ctor_set(x_236, 1, x_234);
-return x_236;
+lean_ctor_set(x_239, 0, x_236);
+lean_ctor_set(x_239, 1, x_237);
+return x_239;
 }
 }
 }
 else
 {
-lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; 
+lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
-x_237 = lean_ctor_get(x_204, 0);
-lean_inc(x_237);
-x_238 = lean_ctor_get(x_204, 1);
-lean_inc(x_238);
-if (lean_is_exclusive(x_204)) {
- lean_ctor_release(x_204, 0);
- lean_ctor_release(x_204, 1);
- x_239 = x_204;
-} else {
- lean_dec_ref(x_204);
- x_239 = lean_box(0);
-}
-if (lean_is_scalar(x_239)) {
- x_240 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_240 = x_239;
-}
-lean_ctor_set(x_240, 0, x_237);
-lean_ctor_set(x_240, 1, x_238);
-return x_240;
-}
-}
-else
-{
-lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; 
-x_241 = lean_ctor_get(x_195, 1);
+x_240 = lean_ctor_get(x_207, 0);
+lean_inc(x_240);
+x_241 = lean_ctor_get(x_207, 1);
 lean_inc(x_241);
-if (lean_is_exclusive(x_195)) {
- lean_ctor_release(x_195, 0);
- lean_ctor_release(x_195, 1);
- x_242 = x_195;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ x_242 = x_207;
 } else {
- lean_dec_ref(x_195);
+ lean_dec_ref(x_207);
  x_242 = lean_box(0);
 }
-x_243 = lean_ctor_get(x_2, 1);
-lean_inc(x_243);
-lean_dec(x_2);
-x_244 = l_Lean_Meta_SimpLemmas_isDeclToUnfold(x_243, x_194);
-lean_dec(x_194);
-if (x_244 == 0)
+if (lean_is_scalar(x_242)) {
+ x_243 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_243 = x_242;
+}
+lean_ctor_set(x_243, 0, x_240);
+lean_ctor_set(x_243, 1, x_241);
+return x_243;
+}
+}
+else
 {
-lean_object* x_245; lean_object* x_246; 
+lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; 
+x_244 = lean_ctor_get(x_198, 1);
+lean_inc(x_244);
+if (lean_is_exclusive(x_198)) {
+ lean_ctor_release(x_198, 0);
+ lean_ctor_release(x_198, 1);
+ x_245 = x_198;
+} else {
+ lean_dec_ref(x_198);
+ x_245 = lean_box(0);
+}
+x_246 = lean_ctor_get(x_2, 1);
+lean_inc(x_246);
+lean_dec(x_2);
+x_247 = l_Lean_Meta_SimpLemmas_isDeclToUnfold(x_246, x_197);
+lean_dec(x_197);
+if (x_247 == 0)
+{
+lean_object* x_248; lean_object* x_249; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_245 = lean_box(0);
-if (lean_is_scalar(x_242)) {
- x_246 = lean_alloc_ctor(0, 2, 0);
+x_248 = lean_box(0);
+if (lean_is_scalar(x_245)) {
+ x_249 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_246 = x_242;
+ x_249 = x_245;
 }
-lean_ctor_set(x_246, 0, x_245);
-lean_ctor_set(x_246, 1, x_241);
-return x_246;
+lean_ctor_set(x_249, 0, x_248);
+lean_ctor_set(x_249, 1, x_244);
+return x_249;
 }
 else
 {
-lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; uint8_t x_252; uint8_t x_253; uint8_t x_254; uint8_t x_255; uint8_t x_256; uint8_t x_257; uint8_t x_258; uint8_t x_259; lean_object* x_260; uint8_t x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; 
-lean_dec(x_242);
-x_247 = lean_ctor_get(x_4, 0);
-lean_inc(x_247);
-x_248 = lean_ctor_get(x_4, 1);
-lean_inc(x_248);
-x_249 = lean_ctor_get(x_4, 2);
-lean_inc(x_249);
-x_250 = lean_ctor_get(x_4, 3);
+lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; uint8_t x_255; uint8_t x_256; uint8_t x_257; uint8_t x_258; uint8_t x_259; uint8_t x_260; uint8_t x_261; uint8_t x_262; uint8_t x_263; lean_object* x_264; uint8_t x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; 
+lean_dec(x_245);
+x_250 = lean_ctor_get(x_4, 0);
 lean_inc(x_250);
+x_251 = lean_ctor_get(x_4, 1);
+lean_inc(x_251);
+x_252 = lean_ctor_get(x_4, 2);
+lean_inc(x_252);
+x_253 = lean_ctor_get(x_4, 3);
+lean_inc(x_253);
 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);
- x_251 = x_4;
+ x_254 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_251 = lean_box(0);
+ x_254 = lean_box(0);
 }
-x_252 = lean_ctor_get_uint8(x_247, 0);
-x_253 = lean_ctor_get_uint8(x_247, 1);
-x_254 = lean_ctor_get_uint8(x_247, 2);
-x_255 = lean_ctor_get_uint8(x_247, 3);
-x_256 = lean_ctor_get_uint8(x_247, 4);
-x_257 = lean_ctor_get_uint8(x_247, 6);
-x_258 = lean_ctor_get_uint8(x_247, 7);
-x_259 = lean_ctor_get_uint8(x_247, 8);
-if (lean_is_exclusive(x_247)) {
- x_260 = x_247;
+x_255 = lean_ctor_get_uint8(x_250, 0);
+x_256 = lean_ctor_get_uint8(x_250, 1);
+x_257 = lean_ctor_get_uint8(x_250, 2);
+x_258 = lean_ctor_get_uint8(x_250, 3);
+x_259 = lean_ctor_get_uint8(x_250, 4);
+x_260 = lean_ctor_get_uint8(x_250, 6);
+x_261 = lean_ctor_get_uint8(x_250, 7);
+x_262 = lean_ctor_get_uint8(x_250, 8);
+x_263 = lean_ctor_get_uint8(x_250, 9);
+if (lean_is_exclusive(x_250)) {
+ x_264 = x_250;
 } else {
- lean_dec_ref(x_247);
- x_260 = lean_box(0);
+ lean_dec_ref(x_250);
+ x_264 = lean_box(0);
 }
-x_261 = 3;
-if (lean_is_scalar(x_260)) {
- x_262 = lean_alloc_ctor(0, 0, 9);
+x_265 = 3;
+if (lean_is_scalar(x_264)) {
+ x_266 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_262 = x_260;
+ x_266 = x_264;
 }
-lean_ctor_set_uint8(x_262, 0, x_252);
-lean_ctor_set_uint8(x_262, 1, x_253);
-lean_ctor_set_uint8(x_262, 2, x_254);
-lean_ctor_set_uint8(x_262, 3, x_255);
-lean_ctor_set_uint8(x_262, 4, x_256);
-lean_ctor_set_uint8(x_262, 5, x_261);
-lean_ctor_set_uint8(x_262, 6, x_257);
-lean_ctor_set_uint8(x_262, 7, x_258);
-lean_ctor_set_uint8(x_262, 8, x_259);
-if (lean_is_scalar(x_251)) {
- x_263 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set_uint8(x_266, 0, x_255);
+lean_ctor_set_uint8(x_266, 1, x_256);
+lean_ctor_set_uint8(x_266, 2, x_257);
+lean_ctor_set_uint8(x_266, 3, x_258);
+lean_ctor_set_uint8(x_266, 4, x_259);
+lean_ctor_set_uint8(x_266, 5, x_265);
+lean_ctor_set_uint8(x_266, 6, x_260);
+lean_ctor_set_uint8(x_266, 7, x_261);
+lean_ctor_set_uint8(x_266, 8, x_262);
+lean_ctor_set_uint8(x_266, 9, x_263);
+if (lean_is_scalar(x_254)) {
+ x_267 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_263 = x_251;
+ x_267 = x_254;
 }
-lean_ctor_set(x_263, 0, x_262);
-lean_ctor_set(x_263, 1, x_248);
-lean_ctor_set(x_263, 2, x_249);
-lean_ctor_set(x_263, 3, x_250);
-x_264 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_263, x_5, x_6, x_7, x_241);
-if (lean_obj_tag(x_264) == 0)
-{
-lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; 
-x_265 = lean_ctor_get(x_264, 0);
-lean_inc(x_265);
-x_266 = lean_ctor_get(x_264, 1);
-lean_inc(x_266);
-if (lean_is_exclusive(x_264)) {
- lean_ctor_release(x_264, 0);
- lean_ctor_release(x_264, 1);
- x_267 = x_264;
-} else {
- lean_dec_ref(x_264);
- x_267 = lean_box(0);
-}
-if (lean_is_scalar(x_267)) {
- x_268 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_268 = x_267;
-}
-lean_ctor_set(x_268, 0, x_265);
-lean_ctor_set(x_268, 1, x_266);
-return x_268;
-}
-else
+lean_ctor_set(x_267, 0, x_266);
+lean_ctor_set(x_267, 1, x_251);
+lean_ctor_set(x_267, 2, x_252);
+lean_ctor_set(x_267, 3, x_253);
+x_268 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_267, x_5, x_6, x_7, x_244);
+if (lean_obj_tag(x_268) == 0)
 {
 lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; 
-x_269 = lean_ctor_get(x_264, 0);
+x_269 = lean_ctor_get(x_268, 0);
 lean_inc(x_269);
-x_270 = lean_ctor_get(x_264, 1);
+x_270 = lean_ctor_get(x_268, 1);
 lean_inc(x_270);
-if (lean_is_exclusive(x_264)) {
- lean_ctor_release(x_264, 0);
- lean_ctor_release(x_264, 1);
- x_271 = x_264;
+if (lean_is_exclusive(x_268)) {
+ lean_ctor_release(x_268, 0);
+ lean_ctor_release(x_268, 1);
+ x_271 = x_268;
 } else {
- lean_dec_ref(x_264);
+ lean_dec_ref(x_268);
  x_271 = lean_box(0);
 }
 if (lean_is_scalar(x_271)) {
- x_272 = lean_alloc_ctor(1, 2, 0);
+ x_272 = lean_alloc_ctor(0, 2, 0);
 } else {
  x_272 = x_271;
 }
@@ -3632,6 +3616,30 @@ lean_ctor_set(x_272, 0, x_269);
 lean_ctor_set(x_272, 1, x_270);
 return x_272;
 }
+else
+{
+lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; 
+x_273 = lean_ctor_get(x_268, 0);
+lean_inc(x_273);
+x_274 = lean_ctor_get(x_268, 1);
+lean_inc(x_274);
+if (lean_is_exclusive(x_268)) {
+ lean_ctor_release(x_268, 0);
+ lean_ctor_release(x_268, 1);
+ x_275 = x_268;
+} else {
+ lean_dec_ref(x_268);
+ x_275 = lean_box(0);
+}
+if (lean_is_scalar(x_275)) {
+ x_276 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_276 = x_275;
+}
+lean_ctor_set(x_276, 0, x_273);
+lean_ctor_set(x_276, 1, x_274);
+return x_276;
+}
 }
 }
 }
@@ -3640,7 +3648,7 @@ return x_272;
 }
 else
 {
-lean_object* x_273; lean_object* x_274; 
+lean_object* x_277; lean_object* x_278; 
 lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -3648,11 +3656,11 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_273 = lean_box(0);
-x_274 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_274, 0, x_273);
-lean_ctor_set(x_274, 1, x_8);
-return x_274;
+x_277 = lean_box(0);
+x_278 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_278, 0, x_277);
+lean_ctor_set(x_278, 1, x_8);
+return x_278;
 }
 }
 }
@@ -3919,7 +3927,7 @@ 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; lean_object* x_37; lean_object* x_38; 
+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; lean_object* x_38; lean_object* x_39; 
 x_28 = lean_ctor_get_uint8(x_16, 0);
 x_29 = lean_ctor_get_uint8(x_16, 1);
 x_30 = lean_ctor_get_uint8(x_16, 2);
@@ -3928,164 +3936,168 @@ x_32 = lean_ctor_get_uint8(x_16, 4);
 x_33 = lean_ctor_get_uint8(x_16, 6);
 x_34 = lean_ctor_get_uint8(x_16, 7);
 x_35 = lean_ctor_get_uint8(x_16, 8);
+x_36 = lean_ctor_get_uint8(x_16, 9);
 lean_dec(x_16);
-x_36 = 1;
-x_37 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, 1, x_29);
-lean_ctor_set_uint8(x_37, 2, x_30);
-lean_ctor_set_uint8(x_37, 3, x_31);
-lean_ctor_set_uint8(x_37, 4, x_32);
-lean_ctor_set_uint8(x_37, 5, x_36);
-lean_ctor_set_uint8(x_37, 6, x_33);
-lean_ctor_set_uint8(x_37, 7, x_34);
-lean_ctor_set_uint8(x_37, 8, x_35);
-lean_ctor_set(x_6, 0, x_37);
-x_38 = l_Lean_Meta_unfoldDefinition_x3f(x_2, x_6, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_38) == 0)
+x_37 = 1;
+x_38 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_38, 0, x_28);
+lean_ctor_set_uint8(x_38, 1, x_29);
+lean_ctor_set_uint8(x_38, 2, x_30);
+lean_ctor_set_uint8(x_38, 3, x_31);
+lean_ctor_set_uint8(x_38, 4, x_32);
+lean_ctor_set_uint8(x_38, 5, x_37);
+lean_ctor_set_uint8(x_38, 6, x_33);
+lean_ctor_set_uint8(x_38, 7, x_34);
+lean_ctor_set_uint8(x_38, 8, x_35);
+lean_ctor_set_uint8(x_38, 9, x_36);
+lean_ctor_set(x_6, 0, x_38);
+x_39 = l_Lean_Meta_unfoldDefinition_x3f(x_2, x_6, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_39) == 0)
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_39 = lean_ctor_get(x_38, 0);
-lean_inc(x_39);
-x_40 = lean_ctor_get(x_38, 1);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_40 = lean_ctor_get(x_39, 0);
 lean_inc(x_40);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- x_41 = x_38;
+x_41 = lean_ctor_get(x_39, 1);
+lean_inc(x_41);
+if (lean_is_exclusive(x_39)) {
+ lean_ctor_release(x_39, 0);
+ lean_ctor_release(x_39, 1);
+ x_42 = x_39;
 } else {
- lean_dec_ref(x_38);
- x_41 = lean_box(0);
+ lean_dec_ref(x_39);
+ x_42 = lean_box(0);
 }
-if (lean_is_scalar(x_41)) {
- x_42 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_42)) {
+ x_43 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_42 = x_41;
+ x_43 = x_42;
 }
-lean_ctor_set(x_42, 0, x_39);
-lean_ctor_set(x_42, 1, x_40);
-return x_42;
+lean_ctor_set(x_43, 0, x_40);
+lean_ctor_set(x_43, 1, x_41);
+return x_43;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_43 = lean_ctor_get(x_38, 0);
-lean_inc(x_43);
-x_44 = lean_ctor_get(x_38, 1);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_44 = lean_ctor_get(x_39, 0);
 lean_inc(x_44);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- x_45 = x_38;
+x_45 = lean_ctor_get(x_39, 1);
+lean_inc(x_45);
+if (lean_is_exclusive(x_39)) {
+ lean_ctor_release(x_39, 0);
+ lean_ctor_release(x_39, 1);
+ x_46 = x_39;
 } else {
- lean_dec_ref(x_38);
- x_45 = lean_box(0);
+ lean_dec_ref(x_39);
+ x_46 = lean_box(0);
 }
-if (lean_is_scalar(x_45)) {
- x_46 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_46)) {
+ x_47 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_46 = x_45;
+ x_47 = x_46;
 }
-lean_ctor_set(x_46, 0, x_43);
-lean_ctor_set(x_46, 1, x_44);
-return x_46;
+lean_ctor_set(x_47, 0, x_44);
+lean_ctor_set(x_47, 1, x_45);
+return x_47;
 }
 }
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_47 = lean_ctor_get(x_6, 0);
-x_48 = lean_ctor_get(x_6, 1);
-x_49 = lean_ctor_get(x_6, 2);
-x_50 = lean_ctor_get(x_6, 3);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; uint8_t x_58; uint8_t x_59; uint8_t x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_48 = lean_ctor_get(x_6, 0);
+x_49 = lean_ctor_get(x_6, 1);
+x_50 = lean_ctor_get(x_6, 2);
+x_51 = lean_ctor_get(x_6, 3);
+lean_inc(x_51);
 lean_inc(x_50);
 lean_inc(x_49);
 lean_inc(x_48);
-lean_inc(x_47);
 lean_dec(x_6);
-x_51 = lean_ctor_get_uint8(x_47, 0);
-x_52 = lean_ctor_get_uint8(x_47, 1);
-x_53 = lean_ctor_get_uint8(x_47, 2);
-x_54 = lean_ctor_get_uint8(x_47, 3);
-x_55 = lean_ctor_get_uint8(x_47, 4);
-x_56 = lean_ctor_get_uint8(x_47, 6);
-x_57 = lean_ctor_get_uint8(x_47, 7);
-x_58 = lean_ctor_get_uint8(x_47, 8);
-if (lean_is_exclusive(x_47)) {
- x_59 = x_47;
+x_52 = lean_ctor_get_uint8(x_48, 0);
+x_53 = lean_ctor_get_uint8(x_48, 1);
+x_54 = lean_ctor_get_uint8(x_48, 2);
+x_55 = lean_ctor_get_uint8(x_48, 3);
+x_56 = lean_ctor_get_uint8(x_48, 4);
+x_57 = lean_ctor_get_uint8(x_48, 6);
+x_58 = lean_ctor_get_uint8(x_48, 7);
+x_59 = lean_ctor_get_uint8(x_48, 8);
+x_60 = lean_ctor_get_uint8(x_48, 9);
+if (lean_is_exclusive(x_48)) {
+ x_61 = x_48;
 } else {
- lean_dec_ref(x_47);
- x_59 = lean_box(0);
+ lean_dec_ref(x_48);
+ x_61 = lean_box(0);
 }
-x_60 = 1;
-if (lean_is_scalar(x_59)) {
- x_61 = lean_alloc_ctor(0, 0, 9);
+x_62 = 1;
+if (lean_is_scalar(x_61)) {
+ x_63 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_61 = x_59;
+ x_63 = x_61;
 }
-lean_ctor_set_uint8(x_61, 0, x_51);
-lean_ctor_set_uint8(x_61, 1, x_52);
-lean_ctor_set_uint8(x_61, 2, x_53);
-lean_ctor_set_uint8(x_61, 3, x_54);
-lean_ctor_set_uint8(x_61, 4, x_55);
-lean_ctor_set_uint8(x_61, 5, x_60);
-lean_ctor_set_uint8(x_61, 6, x_56);
-lean_ctor_set_uint8(x_61, 7, x_57);
-lean_ctor_set_uint8(x_61, 8, x_58);
-x_62 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_62, 0, x_61);
-lean_ctor_set(x_62, 1, x_48);
-lean_ctor_set(x_62, 2, x_49);
-lean_ctor_set(x_62, 3, x_50);
-x_63 = l_Lean_Meta_unfoldDefinition_x3f(x_2, x_62, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_63) == 0)
+lean_ctor_set_uint8(x_63, 0, x_52);
+lean_ctor_set_uint8(x_63, 1, x_53);
+lean_ctor_set_uint8(x_63, 2, x_54);
+lean_ctor_set_uint8(x_63, 3, x_55);
+lean_ctor_set_uint8(x_63, 4, x_56);
+lean_ctor_set_uint8(x_63, 5, x_62);
+lean_ctor_set_uint8(x_63, 6, x_57);
+lean_ctor_set_uint8(x_63, 7, x_58);
+lean_ctor_set_uint8(x_63, 8, x_59);
+lean_ctor_set_uint8(x_63, 9, x_60);
+x_64 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_64, 0, x_63);
+lean_ctor_set(x_64, 1, x_49);
+lean_ctor_set(x_64, 2, x_50);
+lean_ctor_set(x_64, 3, x_51);
+x_65 = l_Lean_Meta_unfoldDefinition_x3f(x_2, x_64, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_65) == 0)
 {
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_64 = lean_ctor_get(x_63, 0);
-lean_inc(x_64);
-x_65 = lean_ctor_get(x_63, 1);
-lean_inc(x_65);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- lean_ctor_release(x_63, 1);
- x_66 = x_63;
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_66 = lean_ctor_get(x_65, 0);
+lean_inc(x_66);
+x_67 = lean_ctor_get(x_65, 1);
+lean_inc(x_67);
+if (lean_is_exclusive(x_65)) {
+ lean_ctor_release(x_65, 0);
+ lean_ctor_release(x_65, 1);
+ x_68 = x_65;
 } else {
- lean_dec_ref(x_63);
- x_66 = lean_box(0);
+ lean_dec_ref(x_65);
+ x_68 = lean_box(0);
 }
-if (lean_is_scalar(x_66)) {
- x_67 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_68)) {
+ x_69 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_67 = x_66;
+ x_69 = x_68;
 }
-lean_ctor_set(x_67, 0, x_64);
-lean_ctor_set(x_67, 1, x_65);
-return x_67;
+lean_ctor_set(x_69, 0, x_66);
+lean_ctor_set(x_69, 1, x_67);
+return x_69;
 }
 else
 {
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-x_68 = lean_ctor_get(x_63, 0);
-lean_inc(x_68);
-x_69 = lean_ctor_get(x_63, 1);
-lean_inc(x_69);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- lean_ctor_release(x_63, 1);
- x_70 = x_63;
+lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+x_70 = lean_ctor_get(x_65, 0);
+lean_inc(x_70);
+x_71 = lean_ctor_get(x_65, 1);
+lean_inc(x_71);
+if (lean_is_exclusive(x_65)) {
+ lean_ctor_release(x_65, 0);
+ lean_ctor_release(x_65, 1);
+ x_72 = x_65;
 } else {
- lean_dec_ref(x_63);
- x_70 = lean_box(0);
+ lean_dec_ref(x_65);
+ x_72 = lean_box(0);
 }
-if (lean_is_scalar(x_70)) {
- x_71 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_72)) {
+ x_73 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_71 = x_70;
+ x_73 = x_72;
 }
-lean_ctor_set(x_71, 0, x_68);
-lean_ctor_set(x_71, 1, x_69);
-return x_71;
+lean_ctor_set(x_73, 0, x_70);
+lean_ctor_set(x_73, 1, x_71);
+return x_73;
 }
 }
 }
@@ -19331,7 +19343,7 @@ return x_32;
 }
 else
 {
-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; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+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; uint8_t x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
 x_33 = lean_ctor_get_uint8(x_10, 0);
 x_34 = lean_ctor_get_uint8(x_10, 1);
 x_35 = lean_ctor_get_uint8(x_10, 2);
@@ -19340,214 +19352,218 @@ x_37 = lean_ctor_get_uint8(x_10, 4);
 x_38 = lean_ctor_get_uint8(x_10, 6);
 x_39 = lean_ctor_get_uint8(x_10, 7);
 x_40 = lean_ctor_get_uint8(x_10, 8);
+x_41 = lean_ctor_get_uint8(x_10, 9);
 lean_dec(x_10);
-x_41 = 2;
-x_42 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_42, 0, x_33);
-lean_ctor_set_uint8(x_42, 1, x_34);
-lean_ctor_set_uint8(x_42, 2, x_35);
-lean_ctor_set_uint8(x_42, 3, x_36);
-lean_ctor_set_uint8(x_42, 4, x_37);
-lean_ctor_set_uint8(x_42, 5, x_41);
-lean_ctor_set_uint8(x_42, 6, x_38);
-lean_ctor_set_uint8(x_42, 7, x_39);
-lean_ctor_set_uint8(x_42, 8, x_40);
-lean_ctor_set(x_4, 0, x_42);
-x_43 = lean_st_ref_get(x_7, x_8);
-x_44 = lean_ctor_get(x_43, 1);
-lean_inc(x_44);
-lean_dec(x_43);
-x_45 = l_Lean_Meta_Simp_main___closed__1;
-x_46 = lean_st_mk_ref(x_45, x_44);
-x_47 = lean_ctor_get(x_46, 0);
-lean_inc(x_47);
-x_48 = lean_ctor_get(x_46, 1);
+x_42 = 2;
+x_43 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_43, 0, x_33);
+lean_ctor_set_uint8(x_43, 1, x_34);
+lean_ctor_set_uint8(x_43, 2, x_35);
+lean_ctor_set_uint8(x_43, 3, x_36);
+lean_ctor_set_uint8(x_43, 4, x_37);
+lean_ctor_set_uint8(x_43, 5, x_42);
+lean_ctor_set_uint8(x_43, 6, x_38);
+lean_ctor_set_uint8(x_43, 7, x_39);
+lean_ctor_set_uint8(x_43, 8, x_40);
+lean_ctor_set_uint8(x_43, 9, x_41);
+lean_ctor_set(x_4, 0, x_43);
+x_44 = lean_st_ref_get(x_7, x_8);
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l_Lean_Meta_Simp_main___closed__1;
+x_47 = lean_st_mk_ref(x_46, x_45);
+x_48 = lean_ctor_get(x_47, 0);
 lean_inc(x_48);
-lean_dec(x_46);
+x_49 = lean_ctor_get(x_47, 1);
+lean_inc(x_49);
+lean_dec(x_47);
 lean_inc(x_7);
-lean_inc(x_47);
-x_49 = l_Lean_Meta_Simp_simp(x_1, x_3, x_2, x_47, x_4, x_5, x_6, x_7, x_48);
-if (lean_obj_tag(x_49) == 0)
+lean_inc(x_48);
+x_50 = l_Lean_Meta_Simp_simp(x_1, x_3, x_2, x_48, x_4, x_5, x_6, x_7, x_49);
+if (lean_obj_tag(x_50) == 0)
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_50 = lean_ctor_get(x_49, 0);
-lean_inc(x_50);
-x_51 = lean_ctor_get(x_49, 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; lean_object* x_58; 
+x_51 = lean_ctor_get(x_50, 0);
 lean_inc(x_51);
-lean_dec(x_49);
-x_52 = lean_st_ref_get(x_7, x_51);
+x_52 = lean_ctor_get(x_50, 1);
+lean_inc(x_52);
+lean_dec(x_50);
+x_53 = lean_st_ref_get(x_7, x_52);
 lean_dec(x_7);
-x_53 = lean_ctor_get(x_52, 1);
-lean_inc(x_53);
-lean_dec(x_52);
-x_54 = lean_st_ref_get(x_47, x_53);
-lean_dec(x_47);
-x_55 = lean_ctor_get(x_54, 1);
-lean_inc(x_55);
-if (lean_is_exclusive(x_54)) {
- lean_ctor_release(x_54, 0);
- lean_ctor_release(x_54, 1);
- x_56 = x_54;
+x_54 = lean_ctor_get(x_53, 1);
+lean_inc(x_54);
+lean_dec(x_53);
+x_55 = lean_st_ref_get(x_48, x_54);
+lean_dec(x_48);
+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_54);
- x_56 = lean_box(0);
+ lean_dec_ref(x_55);
+ x_57 = lean_box(0);
 }
-if (lean_is_scalar(x_56)) {
- x_57 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_57)) {
+ x_58 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_57 = x_56;
+ x_58 = x_57;
 }
-lean_ctor_set(x_57, 0, x_50);
-lean_ctor_set(x_57, 1, x_55);
-return x_57;
+lean_ctor_set(x_58, 0, x_51);
+lean_ctor_set(x_58, 1, x_56);
+return x_58;
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_47);
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+lean_dec(x_48);
 lean_dec(x_7);
-x_58 = lean_ctor_get(x_49, 0);
-lean_inc(x_58);
-x_59 = lean_ctor_get(x_49, 1);
+x_59 = lean_ctor_get(x_50, 0);
 lean_inc(x_59);
-if (lean_is_exclusive(x_49)) {
- lean_ctor_release(x_49, 0);
- lean_ctor_release(x_49, 1);
- x_60 = x_49;
+x_60 = lean_ctor_get(x_50, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_50)) {
+ lean_ctor_release(x_50, 0);
+ lean_ctor_release(x_50, 1);
+ x_61 = x_50;
 } else {
- lean_dec_ref(x_49);
- x_60 = lean_box(0);
+ lean_dec_ref(x_50);
+ x_61 = lean_box(0);
 }
-if (lean_is_scalar(x_60)) {
- x_61 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_61)) {
+ x_62 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_61 = x_60;
+ x_62 = x_61;
 }
-lean_ctor_set(x_61, 0, x_58);
-lean_ctor_set(x_61, 1, x_59);
-return x_61;
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_60);
+return x_62;
 }
 }
 }
 else
 {
-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; lean_object* x_74; uint8_t x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_62 = lean_ctor_get(x_4, 0);
-x_63 = lean_ctor_get(x_4, 1);
-x_64 = lean_ctor_get(x_4, 2);
-x_65 = lean_ctor_get(x_4, 3);
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* 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; lean_object* x_76; uint8_t x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+x_63 = lean_ctor_get(x_4, 0);
+x_64 = lean_ctor_get(x_4, 1);
+x_65 = lean_ctor_get(x_4, 2);
+x_66 = lean_ctor_get(x_4, 3);
+lean_inc(x_66);
 lean_inc(x_65);
 lean_inc(x_64);
 lean_inc(x_63);
-lean_inc(x_62);
 lean_dec(x_4);
-x_66 = lean_ctor_get_uint8(x_62, 0);
-x_67 = lean_ctor_get_uint8(x_62, 1);
-x_68 = lean_ctor_get_uint8(x_62, 2);
-x_69 = lean_ctor_get_uint8(x_62, 3);
-x_70 = lean_ctor_get_uint8(x_62, 4);
-x_71 = lean_ctor_get_uint8(x_62, 6);
-x_72 = lean_ctor_get_uint8(x_62, 7);
-x_73 = lean_ctor_get_uint8(x_62, 8);
-if (lean_is_exclusive(x_62)) {
- x_74 = x_62;
+x_67 = lean_ctor_get_uint8(x_63, 0);
+x_68 = lean_ctor_get_uint8(x_63, 1);
+x_69 = lean_ctor_get_uint8(x_63, 2);
+x_70 = lean_ctor_get_uint8(x_63, 3);
+x_71 = lean_ctor_get_uint8(x_63, 4);
+x_72 = lean_ctor_get_uint8(x_63, 6);
+x_73 = lean_ctor_get_uint8(x_63, 7);
+x_74 = lean_ctor_get_uint8(x_63, 8);
+x_75 = lean_ctor_get_uint8(x_63, 9);
+if (lean_is_exclusive(x_63)) {
+ x_76 = x_63;
 } else {
- lean_dec_ref(x_62);
- x_74 = lean_box(0);
+ lean_dec_ref(x_63);
+ x_76 = lean_box(0);
 }
-x_75 = 2;
-if (lean_is_scalar(x_74)) {
- x_76 = lean_alloc_ctor(0, 0, 9);
+x_77 = 2;
+if (lean_is_scalar(x_76)) {
+ x_78 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_76 = x_74;
+ x_78 = x_76;
 }
-lean_ctor_set_uint8(x_76, 0, x_66);
-lean_ctor_set_uint8(x_76, 1, x_67);
-lean_ctor_set_uint8(x_76, 2, x_68);
-lean_ctor_set_uint8(x_76, 3, x_69);
-lean_ctor_set_uint8(x_76, 4, x_70);
-lean_ctor_set_uint8(x_76, 5, x_75);
-lean_ctor_set_uint8(x_76, 6, x_71);
-lean_ctor_set_uint8(x_76, 7, x_72);
-lean_ctor_set_uint8(x_76, 8, x_73);
-x_77 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_77, 0, x_76);
-lean_ctor_set(x_77, 1, x_63);
-lean_ctor_set(x_77, 2, x_64);
-lean_ctor_set(x_77, 3, x_65);
-x_78 = lean_st_ref_get(x_7, x_8);
-x_79 = lean_ctor_get(x_78, 1);
-lean_inc(x_79);
-lean_dec(x_78);
-x_80 = l_Lean_Meta_Simp_main___closed__1;
-x_81 = lean_st_mk_ref(x_80, x_79);
-x_82 = lean_ctor_get(x_81, 0);
-lean_inc(x_82);
-x_83 = lean_ctor_get(x_81, 1);
-lean_inc(x_83);
-lean_dec(x_81);
-lean_inc(x_7);
-lean_inc(x_82);
-x_84 = l_Lean_Meta_Simp_simp(x_1, x_3, x_2, x_82, x_77, x_5, x_6, x_7, x_83);
-if (lean_obj_tag(x_84) == 0)
-{
-lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-x_85 = lean_ctor_get(x_84, 0);
+lean_ctor_set_uint8(x_78, 0, x_67);
+lean_ctor_set_uint8(x_78, 1, x_68);
+lean_ctor_set_uint8(x_78, 2, x_69);
+lean_ctor_set_uint8(x_78, 3, x_70);
+lean_ctor_set_uint8(x_78, 4, x_71);
+lean_ctor_set_uint8(x_78, 5, x_77);
+lean_ctor_set_uint8(x_78, 6, x_72);
+lean_ctor_set_uint8(x_78, 7, x_73);
+lean_ctor_set_uint8(x_78, 8, x_74);
+lean_ctor_set_uint8(x_78, 9, x_75);
+x_79 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_79, 0, x_78);
+lean_ctor_set(x_79, 1, x_64);
+lean_ctor_set(x_79, 2, x_65);
+lean_ctor_set(x_79, 3, x_66);
+x_80 = lean_st_ref_get(x_7, x_8);
+x_81 = lean_ctor_get(x_80, 1);
+lean_inc(x_81);
+lean_dec(x_80);
+x_82 = l_Lean_Meta_Simp_main___closed__1;
+x_83 = lean_st_mk_ref(x_82, x_81);
+x_84 = lean_ctor_get(x_83, 0);
+lean_inc(x_84);
+x_85 = lean_ctor_get(x_83, 1);
 lean_inc(x_85);
-x_86 = lean_ctor_get(x_84, 1);
-lean_inc(x_86);
-lean_dec(x_84);
-x_87 = lean_st_ref_get(x_7, x_86);
-lean_dec(x_7);
-x_88 = lean_ctor_get(x_87, 1);
+lean_dec(x_83);
+lean_inc(x_7);
+lean_inc(x_84);
+x_86 = l_Lean_Meta_Simp_simp(x_1, x_3, x_2, x_84, x_79, x_5, x_6, x_7, x_85);
+if (lean_obj_tag(x_86) == 0)
+{
+lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; 
+x_87 = lean_ctor_get(x_86, 0);
+lean_inc(x_87);
+x_88 = lean_ctor_get(x_86, 1);
 lean_inc(x_88);
-lean_dec(x_87);
-x_89 = lean_st_ref_get(x_82, x_88);
-lean_dec(x_82);
+lean_dec(x_86);
+x_89 = lean_st_ref_get(x_7, x_88);
+lean_dec(x_7);
 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;
+lean_dec(x_89);
+x_91 = lean_st_ref_get(x_84, x_90);
+lean_dec(x_84);
+x_92 = lean_ctor_get(x_91, 1);
+lean_inc(x_92);
+if (lean_is_exclusive(x_91)) {
+ lean_ctor_release(x_91, 0);
+ lean_ctor_release(x_91, 1);
+ x_93 = x_91;
 } else {
- lean_dec_ref(x_89);
- x_91 = lean_box(0);
+ lean_dec_ref(x_91);
+ x_93 = lean_box(0);
 }
-if (lean_is_scalar(x_91)) {
- x_92 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_93)) {
+ x_94 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_92 = x_91;
+ x_94 = x_93;
 }
-lean_ctor_set(x_92, 0, x_85);
-lean_ctor_set(x_92, 1, x_90);
-return x_92;
+lean_ctor_set(x_94, 0, x_87);
+lean_ctor_set(x_94, 1, x_92);
+return x_94;
 }
 else
 {
-lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; 
-lean_dec(x_82);
+lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
+lean_dec(x_84);
 lean_dec(x_7);
-x_93 = lean_ctor_get(x_84, 0);
-lean_inc(x_93);
-x_94 = lean_ctor_get(x_84, 1);
-lean_inc(x_94);
-if (lean_is_exclusive(x_84)) {
- lean_ctor_release(x_84, 0);
- lean_ctor_release(x_84, 1);
- x_95 = x_84;
+x_95 = lean_ctor_get(x_86, 0);
+lean_inc(x_95);
+x_96 = lean_ctor_get(x_86, 1);
+lean_inc(x_96);
+if (lean_is_exclusive(x_86)) {
+ lean_ctor_release(x_86, 0);
+ lean_ctor_release(x_86, 1);
+ x_97 = x_86;
 } else {
- lean_dec_ref(x_84);
- x_95 = lean_box(0);
+ lean_dec_ref(x_86);
+ x_97 = lean_box(0);
 }
-if (lean_is_scalar(x_95)) {
- x_96 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_97)) {
+ x_98 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_96 = x_95;
+ x_98 = x_97;
 }
-lean_ctor_set(x_96, 0, x_93);
-lean_ctor_set(x_96, 1, x_94);
-return x_96;
+lean_ctor_set(x_98, 0, x_95);
+lean_ctor_set(x_98, 1, x_96);
+return x_98;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Simp/Rewrite.c b/stage0/stdlib/Lean/Meta/Tactic/Simp/Rewrite.c
index 7f8d972798..3f774a3c71 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Simp/Rewrite.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Simp/Rewrite.c
@@ -14,10 +14,8 @@
 extern "C" {
 #endif
 uint8_t l_Lean_Meta_Simp_rewrite_inErasedSet(lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 size_t l_USize_add(size_t, size_t);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewMCtxDepthImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
 lean_object* l_Lean_stringToMessageData(lean_object*);
 extern lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__4___closed__1;
 lean_object* l_Lean_Meta_Simp_rewrite_tryLemma_x3f___lambda__4___closed__2;
@@ -29,6 +27,7 @@ lean_object* l_Lean_Meta_Simp_rewriteUsingDecide_x3f(lean_object*, lean_object*,
 lean_object* l_Lean_Meta_Simp_rewriteCtorEq_x3f_match__1(lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_MonadEnv_0__Lean_supportedRecursors___closed__5;
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Lean_Meta_Simp_tryRewriteUsingDecide(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Simp_rewrite_tryLemma_x3f___lambda__6___closed__1;
@@ -39,6 +38,7 @@ lean_object* l_Lean_Meta_Simp_rewrite_tryLemma_x3f___lambda__3(lean_object*, lea
 lean_object* lean_array_fswap(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Simp_rewrite_tryLemma_x3f___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_Simp_synthesizeArgs___spec__1___closed__3;
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_Meta_Simp_rewrite_tryLemma_x3f___lambda__6___closed__2;
 lean_object* l_Lean_Meta_withNewMCtxDepth___at_Lean_Meta_Simp_rewrite_tryLemma_x3f___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Simp_rewrite_tryLemma_x3f___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*, lean_object*);
@@ -575,7 +575,7 @@ static lean_object* _init_l_Lean_Meta_Simp_synthesizeArgs_synthesizeInstance___c
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Parser_Tactic_intro___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -4980,7 +4980,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Meta_Simp_rewrite___closed__2;
-x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__1;
+x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -6072,7 +6072,7 @@ return x_95;
 }
 else
 {
-uint8_t x_96; uint8_t x_97; uint8_t x_98; uint8_t x_99; uint8_t x_100; uint8_t x_101; uint8_t x_102; uint8_t x_103; uint8_t x_104; lean_object* x_105; lean_object* x_106; 
+uint8_t x_96; uint8_t x_97; uint8_t x_98; uint8_t x_99; uint8_t x_100; uint8_t x_101; uint8_t x_102; uint8_t x_103; uint8_t x_104; uint8_t x_105; lean_object* x_106; lean_object* x_107; 
 x_96 = lean_ctor_get_uint8(x_16, 0);
 x_97 = lean_ctor_get_uint8(x_16, 1);
 x_98 = lean_ctor_get_uint8(x_16, 2);
@@ -6081,578 +6081,582 @@ x_100 = lean_ctor_get_uint8(x_16, 4);
 x_101 = lean_ctor_get_uint8(x_16, 6);
 x_102 = lean_ctor_get_uint8(x_16, 7);
 x_103 = lean_ctor_get_uint8(x_16, 8);
+x_104 = lean_ctor_get_uint8(x_16, 9);
 lean_dec(x_16);
-x_104 = 3;
-x_105 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_105, 0, x_96);
-lean_ctor_set_uint8(x_105, 1, x_97);
-lean_ctor_set_uint8(x_105, 2, x_98);
-lean_ctor_set_uint8(x_105, 3, x_99);
-lean_ctor_set_uint8(x_105, 4, x_100);
-lean_ctor_set_uint8(x_105, 5, x_104);
-lean_ctor_set_uint8(x_105, 6, x_101);
-lean_ctor_set_uint8(x_105, 7, x_102);
-lean_ctor_set_uint8(x_105, 8, x_103);
-lean_ctor_set(x_2, 0, x_105);
+x_105 = 3;
+x_106 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_106, 0, x_96);
+lean_ctor_set_uint8(x_106, 1, x_97);
+lean_ctor_set_uint8(x_106, 2, x_98);
+lean_ctor_set_uint8(x_106, 3, x_99);
+lean_ctor_set_uint8(x_106, 4, x_100);
+lean_ctor_set_uint8(x_106, 5, x_105);
+lean_ctor_set_uint8(x_106, 6, x_101);
+lean_ctor_set_uint8(x_106, 7, x_102);
+lean_ctor_set_uint8(x_106, 8, x_103);
+lean_ctor_set_uint8(x_106, 9, x_104);
+lean_ctor_set(x_2, 0, x_106);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-x_106 = l_Lean_Meta_whnf(x_13, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_106) == 0)
+x_107 = l_Lean_Meta_whnf(x_13, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_107) == 0)
 {
-lean_object* x_107; lean_object* x_108; lean_object* x_109; 
-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; 
+x_108 = lean_ctor_get(x_107, 0);
 lean_inc(x_108);
-lean_dec(x_106);
+x_109 = lean_ctor_get(x_107, 1);
+lean_inc(x_109);
+lean_dec(x_107);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-x_109 = l_Lean_Meta_whnf(x_14, x_2, x_3, x_4, x_5, x_108);
-if (lean_obj_tag(x_109) == 0)
+x_110 = l_Lean_Meta_whnf(x_14, x_2, x_3, x_4, x_5, x_109);
+if (lean_obj_tag(x_110) == 0)
 {
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
-x_110 = lean_ctor_get(x_109, 0);
-lean_inc(x_110);
-x_111 = lean_ctor_get(x_109, 1);
+lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
+x_111 = lean_ctor_get(x_110, 0);
 lean_inc(x_111);
-lean_dec(x_109);
-x_112 = lean_st_ref_get(x_5, x_111);
-x_113 = lean_ctor_get(x_112, 0);
-lean_inc(x_113);
-x_114 = lean_ctor_get(x_112, 1);
-lean_inc(x_114);
-if (lean_is_exclusive(x_112)) {
- lean_ctor_release(x_112, 0);
- lean_ctor_release(x_112, 1);
- x_115 = x_112;
-} else {
- lean_dec_ref(x_112);
- x_115 = lean_box(0);
-}
-x_116 = lean_ctor_get(x_113, 0);
-lean_inc(x_116);
-lean_dec(x_113);
-lean_inc(x_116);
-x_117 = l_Lean_Expr_constructorApp_x3f(x_116, x_107);
-if (lean_obj_tag(x_117) == 0)
-{
-lean_object* x_118; lean_object* x_119; 
-lean_dec(x_116);
+x_112 = lean_ctor_get(x_110, 1);
+lean_inc(x_112);
 lean_dec(x_110);
-lean_dec(x_2);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_118 = lean_box(0);
-if (lean_is_scalar(x_115)) {
- x_119 = lean_alloc_ctor(0, 2, 0);
+x_113 = lean_st_ref_get(x_5, x_112);
+x_114 = lean_ctor_get(x_113, 0);
+lean_inc(x_114);
+x_115 = lean_ctor_get(x_113, 1);
+lean_inc(x_115);
+if (lean_is_exclusive(x_113)) {
+ lean_ctor_release(x_113, 0);
+ lean_ctor_release(x_113, 1);
+ x_116 = x_113;
 } else {
- x_119 = x_115;
+ lean_dec_ref(x_113);
+ x_116 = lean_box(0);
 }
-lean_ctor_set(x_119, 0, x_118);
-lean_ctor_set(x_119, 1, x_114);
-return x_119;
-}
-else
+x_117 = lean_ctor_get(x_114, 0);
+lean_inc(x_117);
+lean_dec(x_114);
+lean_inc(x_117);
+x_118 = l_Lean_Expr_constructorApp_x3f(x_117, x_108);
+if (lean_obj_tag(x_118) == 0)
 {
-lean_object* x_120; lean_object* x_121; 
-x_120 = lean_ctor_get(x_117, 0);
-lean_inc(x_120);
+lean_object* x_119; lean_object* x_120; 
 lean_dec(x_117);
-x_121 = l_Lean_Expr_constructorApp_x3f(x_116, x_110);
-if (lean_obj_tag(x_121) == 0)
-{
-lean_object* x_122; lean_object* x_123; 
-lean_dec(x_120);
+lean_dec(x_111);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_122 = lean_box(0);
-if (lean_is_scalar(x_115)) {
- x_123 = lean_alloc_ctor(0, 2, 0);
+x_119 = lean_box(0);
+if (lean_is_scalar(x_116)) {
+ x_120 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_123 = x_115;
+ x_120 = x_116;
 }
-lean_ctor_set(x_123, 0, x_122);
-lean_ctor_set(x_123, 1, x_114);
-return x_123;
+lean_ctor_set(x_120, 0, x_119);
+lean_ctor_set(x_120, 1, x_115);
+return x_120;
 }
 else
 {
-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; uint8_t x_131; 
-x_124 = lean_ctor_get(x_121, 0);
-lean_inc(x_124);
+lean_object* x_121; lean_object* x_122; 
+x_121 = lean_ctor_get(x_118, 0);
+lean_inc(x_121);
+lean_dec(x_118);
+x_122 = l_Lean_Expr_constructorApp_x3f(x_117, x_111);
+if (lean_obj_tag(x_122) == 0)
+{
+lean_object* x_123; lean_object* x_124; 
 lean_dec(x_121);
-x_125 = lean_ctor_get(x_120, 0);
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_123 = lean_box(0);
+if (lean_is_scalar(x_116)) {
+ x_124 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_124 = x_116;
+}
+lean_ctor_set(x_124, 0, x_123);
+lean_ctor_set(x_124, 1, x_115);
+return x_124;
+}
+else
+{
+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; uint8_t x_132; 
+x_125 = lean_ctor_get(x_122, 0);
 lean_inc(x_125);
-lean_dec(x_120);
-x_126 = lean_ctor_get(x_124, 0);
+lean_dec(x_122);
+x_126 = lean_ctor_get(x_121, 0);
 lean_inc(x_126);
-lean_dec(x_124);
+lean_dec(x_121);
 x_127 = lean_ctor_get(x_125, 0);
 lean_inc(x_127);
 lean_dec(x_125);
-x_128 = lean_ctor_get(x_127, 0);
+x_128 = lean_ctor_get(x_126, 0);
 lean_inc(x_128);
-lean_dec(x_127);
-x_129 = lean_ctor_get(x_126, 0);
-lean_inc(x_129);
 lean_dec(x_126);
-x_130 = lean_ctor_get(x_129, 0);
-lean_inc(x_130);
-lean_dec(x_129);
-x_131 = lean_name_eq(x_128, x_130);
-lean_dec(x_130);
+x_129 = lean_ctor_get(x_128, 0);
+lean_inc(x_129);
 lean_dec(x_128);
-if (x_131 == 0)
+x_130 = lean_ctor_get(x_127, 0);
+lean_inc(x_130);
+lean_dec(x_127);
+x_131 = lean_ctor_get(x_130, 0);
+lean_inc(x_131);
+lean_dec(x_130);
+x_132 = lean_name_eq(x_129, x_131);
+lean_dec(x_131);
+lean_dec(x_129);
+if (x_132 == 0)
 {
-lean_object* x_132; uint8_t x_133; lean_object* x_134; lean_object* x_135; 
-lean_dec(x_115);
-x_132 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__2;
-x_133 = 0;
-x_134 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__3;
-x_135 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_isPerm___spec__1___rarg(x_132, x_133, x_1, x_134, x_2, x_3, x_4, x_5, x_114);
-if (lean_obj_tag(x_135) == 0)
+lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; 
+lean_dec(x_116);
+x_133 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__2;
+x_134 = 0;
+x_135 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__3;
+x_136 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_isPerm___spec__1___rarg(x_133, x_134, x_1, x_135, x_2, x_3, x_4, x_5, x_115);
+if (lean_obj_tag(x_136) == 0)
 {
-lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; 
-x_136 = lean_ctor_get(x_135, 0);
-lean_inc(x_136);
-x_137 = lean_ctor_get(x_135, 1);
+lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
+x_137 = lean_ctor_get(x_136, 0);
 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;
+x_138 = lean_ctor_get(x_136, 1);
+lean_inc(x_138);
+if (lean_is_exclusive(x_136)) {
+ lean_ctor_release(x_136, 0);
+ lean_ctor_release(x_136, 1);
+ x_139 = x_136;
 } else {
- lean_dec_ref(x_135);
- x_138 = lean_box(0);
+ lean_dec_ref(x_136);
+ x_139 = lean_box(0);
 }
-if (lean_is_scalar(x_138)) {
- x_139 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_139)) {
+ x_140 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_139 = x_138;
+ x_140 = x_139;
 }
-lean_ctor_set(x_139, 0, x_136);
-lean_ctor_set(x_139, 1, x_137);
-return x_139;
+lean_ctor_set(x_140, 0, x_137);
+lean_ctor_set(x_140, 1, x_138);
+return x_140;
 }
 else
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_140 = lean_ctor_get(x_135, 0);
-lean_inc(x_140);
-x_141 = lean_ctor_get(x_135, 1);
+lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; 
+x_141 = lean_ctor_get(x_136, 0);
 lean_inc(x_141);
-if (lean_is_exclusive(x_135)) {
- lean_ctor_release(x_135, 0);
- lean_ctor_release(x_135, 1);
- x_142 = x_135;
+x_142 = lean_ctor_get(x_136, 1);
+lean_inc(x_142);
+if (lean_is_exclusive(x_136)) {
+ lean_ctor_release(x_136, 0);
+ lean_ctor_release(x_136, 1);
+ x_143 = x_136;
 } else {
- lean_dec_ref(x_135);
- x_142 = lean_box(0);
+ lean_dec_ref(x_136);
+ x_143 = lean_box(0);
 }
-if (lean_is_scalar(x_142)) {
- x_143 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_143)) {
+ x_144 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_143 = x_142;
+ x_144 = x_143;
 }
-lean_ctor_set(x_143, 0, x_140);
-lean_ctor_set(x_143, 1, x_141);
-return x_143;
+lean_ctor_set(x_144, 0, x_141);
+lean_ctor_set(x_144, 1, x_142);
+return x_144;
 }
 }
 else
 {
-lean_object* x_144; lean_object* x_145; 
+lean_object* x_145; lean_object* x_146; 
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_144 = lean_box(0);
-if (lean_is_scalar(x_115)) {
- x_145 = lean_alloc_ctor(0, 2, 0);
+x_145 = lean_box(0);
+if (lean_is_scalar(x_116)) {
+ x_146 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_145 = x_115;
+ x_146 = x_116;
 }
-lean_ctor_set(x_145, 0, x_144);
-lean_ctor_set(x_145, 1, x_114);
-return x_145;
+lean_ctor_set(x_146, 0, x_145);
+lean_ctor_set(x_146, 1, x_115);
+return x_146;
 }
 }
 }
 }
 else
 {
-lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; 
-lean_dec(x_107);
+lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; 
+lean_dec(x_108);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_146 = lean_ctor_get(x_109, 0);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_109, 1);
+x_147 = lean_ctor_get(x_110, 0);
 lean_inc(x_147);
-if (lean_is_exclusive(x_109)) {
- lean_ctor_release(x_109, 0);
- lean_ctor_release(x_109, 1);
- x_148 = x_109;
+x_148 = lean_ctor_get(x_110, 1);
+lean_inc(x_148);
+if (lean_is_exclusive(x_110)) {
+ lean_ctor_release(x_110, 0);
+ lean_ctor_release(x_110, 1);
+ x_149 = x_110;
 } else {
- lean_dec_ref(x_109);
- x_148 = lean_box(0);
+ lean_dec_ref(x_110);
+ x_149 = lean_box(0);
 }
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_149)) {
+ x_150 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_149 = x_148;
+ x_150 = x_149;
 }
-lean_ctor_set(x_149, 0, x_146);
-lean_ctor_set(x_149, 1, x_147);
-return x_149;
+lean_ctor_set(x_150, 0, x_147);
+lean_ctor_set(x_150, 1, x_148);
+return x_150;
 }
 }
 else
 {
-lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; 
+lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; 
 lean_dec(x_2);
 lean_dec(x_14);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_150 = lean_ctor_get(x_106, 0);
-lean_inc(x_150);
-x_151 = lean_ctor_get(x_106, 1);
+x_151 = lean_ctor_get(x_107, 0);
 lean_inc(x_151);
-if (lean_is_exclusive(x_106)) {
- lean_ctor_release(x_106, 0);
- lean_ctor_release(x_106, 1);
- x_152 = x_106;
+x_152 = lean_ctor_get(x_107, 1);
+lean_inc(x_152);
+if (lean_is_exclusive(x_107)) {
+ lean_ctor_release(x_107, 0);
+ lean_ctor_release(x_107, 1);
+ x_153 = x_107;
 } else {
- lean_dec_ref(x_106);
- x_152 = lean_box(0);
+ lean_dec_ref(x_107);
+ x_153 = lean_box(0);
 }
-if (lean_is_scalar(x_152)) {
- x_153 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_153)) {
+ x_154 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_153 = x_152;
+ x_154 = x_153;
 }
-lean_ctor_set(x_153, 0, x_150);
-lean_ctor_set(x_153, 1, x_151);
-return x_153;
+lean_ctor_set(x_154, 0, x_151);
+lean_ctor_set(x_154, 1, x_152);
+return x_154;
 }
 }
 }
 else
 {
-lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; uint8_t x_158; uint8_t x_159; uint8_t x_160; uint8_t x_161; uint8_t x_162; uint8_t x_163; uint8_t x_164; uint8_t x_165; lean_object* x_166; uint8_t x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; 
-x_154 = lean_ctor_get(x_2, 0);
-x_155 = lean_ctor_get(x_2, 1);
-x_156 = lean_ctor_get(x_2, 2);
-x_157 = lean_ctor_get(x_2, 3);
+lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; uint8_t x_159; uint8_t x_160; uint8_t x_161; uint8_t x_162; uint8_t x_163; uint8_t x_164; uint8_t x_165; uint8_t x_166; uint8_t x_167; lean_object* x_168; uint8_t x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; 
+x_155 = lean_ctor_get(x_2, 0);
+x_156 = lean_ctor_get(x_2, 1);
+x_157 = lean_ctor_get(x_2, 2);
+x_158 = lean_ctor_get(x_2, 3);
+lean_inc(x_158);
 lean_inc(x_157);
 lean_inc(x_156);
 lean_inc(x_155);
-lean_inc(x_154);
 lean_dec(x_2);
-x_158 = lean_ctor_get_uint8(x_154, 0);
-x_159 = lean_ctor_get_uint8(x_154, 1);
-x_160 = lean_ctor_get_uint8(x_154, 2);
-x_161 = lean_ctor_get_uint8(x_154, 3);
-x_162 = lean_ctor_get_uint8(x_154, 4);
-x_163 = lean_ctor_get_uint8(x_154, 6);
-x_164 = lean_ctor_get_uint8(x_154, 7);
-x_165 = lean_ctor_get_uint8(x_154, 8);
-if (lean_is_exclusive(x_154)) {
- x_166 = x_154;
+x_159 = lean_ctor_get_uint8(x_155, 0);
+x_160 = lean_ctor_get_uint8(x_155, 1);
+x_161 = lean_ctor_get_uint8(x_155, 2);
+x_162 = lean_ctor_get_uint8(x_155, 3);
+x_163 = lean_ctor_get_uint8(x_155, 4);
+x_164 = lean_ctor_get_uint8(x_155, 6);
+x_165 = lean_ctor_get_uint8(x_155, 7);
+x_166 = lean_ctor_get_uint8(x_155, 8);
+x_167 = lean_ctor_get_uint8(x_155, 9);
+if (lean_is_exclusive(x_155)) {
+ x_168 = x_155;
 } else {
- lean_dec_ref(x_154);
- x_166 = lean_box(0);
+ lean_dec_ref(x_155);
+ x_168 = lean_box(0);
 }
-x_167 = 3;
-if (lean_is_scalar(x_166)) {
- x_168 = lean_alloc_ctor(0, 0, 9);
+x_169 = 3;
+if (lean_is_scalar(x_168)) {
+ x_170 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_168 = x_166;
+ x_170 = x_168;
 }
-lean_ctor_set_uint8(x_168, 0, x_158);
-lean_ctor_set_uint8(x_168, 1, x_159);
-lean_ctor_set_uint8(x_168, 2, x_160);
-lean_ctor_set_uint8(x_168, 3, x_161);
-lean_ctor_set_uint8(x_168, 4, x_162);
-lean_ctor_set_uint8(x_168, 5, x_167);
-lean_ctor_set_uint8(x_168, 6, x_163);
-lean_ctor_set_uint8(x_168, 7, x_164);
-lean_ctor_set_uint8(x_168, 8, x_165);
-x_169 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_169, 0, x_168);
-lean_ctor_set(x_169, 1, x_155);
-lean_ctor_set(x_169, 2, x_156);
-lean_ctor_set(x_169, 3, x_157);
+lean_ctor_set_uint8(x_170, 0, x_159);
+lean_ctor_set_uint8(x_170, 1, x_160);
+lean_ctor_set_uint8(x_170, 2, x_161);
+lean_ctor_set_uint8(x_170, 3, x_162);
+lean_ctor_set_uint8(x_170, 4, x_163);
+lean_ctor_set_uint8(x_170, 5, x_169);
+lean_ctor_set_uint8(x_170, 6, x_164);
+lean_ctor_set_uint8(x_170, 7, x_165);
+lean_ctor_set_uint8(x_170, 8, x_166);
+lean_ctor_set_uint8(x_170, 9, x_167);
+x_171 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_171, 0, x_170);
+lean_ctor_set(x_171, 1, x_156);
+lean_ctor_set(x_171, 2, x_157);
+lean_ctor_set(x_171, 3, x_158);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_169);
-x_170 = l_Lean_Meta_whnf(x_13, x_169, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_170) == 0)
-{
-lean_object* x_171; lean_object* x_172; lean_object* x_173; 
-x_171 = lean_ctor_get(x_170, 0);
 lean_inc(x_171);
-x_172 = lean_ctor_get(x_170, 1);
-lean_inc(x_172);
-lean_dec(x_170);
+x_172 = l_Lean_Meta_whnf(x_13, x_171, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_172) == 0)
+{
+lean_object* x_173; lean_object* x_174; lean_object* x_175; 
+x_173 = lean_ctor_get(x_172, 0);
+lean_inc(x_173);
+x_174 = lean_ctor_get(x_172, 1);
+lean_inc(x_174);
+lean_dec(x_172);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_169);
-x_173 = l_Lean_Meta_whnf(x_14, x_169, x_3, x_4, x_5, x_172);
-if (lean_obj_tag(x_173) == 0)
+lean_inc(x_171);
+x_175 = l_Lean_Meta_whnf(x_14, x_171, x_3, x_4, x_5, x_174);
+if (lean_obj_tag(x_175) == 0)
 {
-lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; 
-x_174 = lean_ctor_get(x_173, 0);
-lean_inc(x_174);
-x_175 = lean_ctor_get(x_173, 1);
-lean_inc(x_175);
-lean_dec(x_173);
-x_176 = lean_st_ref_get(x_5, x_175);
-x_177 = lean_ctor_get(x_176, 0);
+lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; 
+x_176 = lean_ctor_get(x_175, 0);
+lean_inc(x_176);
+x_177 = lean_ctor_get(x_175, 1);
 lean_inc(x_177);
-x_178 = lean_ctor_get(x_176, 1);
-lean_inc(x_178);
-if (lean_is_exclusive(x_176)) {
- lean_ctor_release(x_176, 0);
- lean_ctor_release(x_176, 1);
- x_179 = x_176;
-} else {
- lean_dec_ref(x_176);
- x_179 = lean_box(0);
-}
-x_180 = lean_ctor_get(x_177, 0);
+lean_dec(x_175);
+x_178 = lean_st_ref_get(x_5, x_177);
+x_179 = lean_ctor_get(x_178, 0);
+lean_inc(x_179);
+x_180 = lean_ctor_get(x_178, 1);
 lean_inc(x_180);
-lean_dec(x_177);
-lean_inc(x_180);
-x_181 = l_Lean_Expr_constructorApp_x3f(x_180, x_171);
-if (lean_obj_tag(x_181) == 0)
-{
-lean_object* x_182; lean_object* x_183; 
-lean_dec(x_180);
-lean_dec(x_174);
-lean_dec(x_169);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_182 = lean_box(0);
-if (lean_is_scalar(x_179)) {
- x_183 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_exclusive(x_178)) {
+ lean_ctor_release(x_178, 0);
+ lean_ctor_release(x_178, 1);
+ x_181 = x_178;
 } else {
- x_183 = x_179;
+ lean_dec_ref(x_178);
+ x_181 = lean_box(0);
 }
-lean_ctor_set(x_183, 0, x_182);
-lean_ctor_set(x_183, 1, x_178);
-return x_183;
-}
-else
+x_182 = lean_ctor_get(x_179, 0);
+lean_inc(x_182);
+lean_dec(x_179);
+lean_inc(x_182);
+x_183 = l_Lean_Expr_constructorApp_x3f(x_182, x_173);
+if (lean_obj_tag(x_183) == 0)
 {
 lean_object* x_184; lean_object* x_185; 
-x_184 = lean_ctor_get(x_181, 0);
-lean_inc(x_184);
-lean_dec(x_181);
-x_185 = l_Lean_Expr_constructorApp_x3f(x_180, x_174);
-if (lean_obj_tag(x_185) == 0)
-{
-lean_object* x_186; lean_object* x_187; 
-lean_dec(x_184);
-lean_dec(x_169);
+lean_dec(x_182);
+lean_dec(x_176);
+lean_dec(x_171);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_186 = lean_box(0);
-if (lean_is_scalar(x_179)) {
- x_187 = lean_alloc_ctor(0, 2, 0);
+x_184 = lean_box(0);
+if (lean_is_scalar(x_181)) {
+ x_185 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_187 = x_179;
+ x_185 = x_181;
 }
-lean_ctor_set(x_187, 0, x_186);
-lean_ctor_set(x_187, 1, x_178);
-return x_187;
+lean_ctor_set(x_185, 0, x_184);
+lean_ctor_set(x_185, 1, x_180);
+return x_185;
 }
 else
 {
-lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_188 = lean_ctor_get(x_185, 0);
-lean_inc(x_188);
-lean_dec(x_185);
-x_189 = lean_ctor_get(x_184, 0);
-lean_inc(x_189);
-lean_dec(x_184);
-x_190 = lean_ctor_get(x_188, 0);
+lean_object* x_186; lean_object* x_187; 
+x_186 = lean_ctor_get(x_183, 0);
+lean_inc(x_186);
+lean_dec(x_183);
+x_187 = l_Lean_Expr_constructorApp_x3f(x_182, x_176);
+if (lean_obj_tag(x_187) == 0)
+{
+lean_object* x_188; lean_object* x_189; 
+lean_dec(x_186);
+lean_dec(x_171);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_188 = lean_box(0);
+if (lean_is_scalar(x_181)) {
+ x_189 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_189 = x_181;
+}
+lean_ctor_set(x_189, 0, x_188);
+lean_ctor_set(x_189, 1, x_180);
+return x_189;
+}
+else
+{
+lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; uint8_t x_197; 
+x_190 = lean_ctor_get(x_187, 0);
 lean_inc(x_190);
-lean_dec(x_188);
-x_191 = lean_ctor_get(x_189, 0);
+lean_dec(x_187);
+x_191 = lean_ctor_get(x_186, 0);
 lean_inc(x_191);
-lean_dec(x_189);
-x_192 = lean_ctor_get(x_191, 0);
+lean_dec(x_186);
+x_192 = lean_ctor_get(x_190, 0);
 lean_inc(x_192);
-lean_dec(x_191);
-x_193 = lean_ctor_get(x_190, 0);
-lean_inc(x_193);
 lean_dec(x_190);
+x_193 = lean_ctor_get(x_191, 0);
+lean_inc(x_193);
+lean_dec(x_191);
 x_194 = lean_ctor_get(x_193, 0);
 lean_inc(x_194);
 lean_dec(x_193);
-x_195 = lean_name_eq(x_192, x_194);
-lean_dec(x_194);
+x_195 = lean_ctor_get(x_192, 0);
+lean_inc(x_195);
 lean_dec(x_192);
-if (x_195 == 0)
+x_196 = lean_ctor_get(x_195, 0);
+lean_inc(x_196);
+lean_dec(x_195);
+x_197 = lean_name_eq(x_194, x_196);
+lean_dec(x_196);
+lean_dec(x_194);
+if (x_197 == 0)
 {
-lean_object* x_196; uint8_t x_197; lean_object* x_198; lean_object* x_199; 
-lean_dec(x_179);
-x_196 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__2;
-x_197 = 0;
-x_198 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__3;
-x_199 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_isPerm___spec__1___rarg(x_196, x_197, x_1, x_198, x_169, x_3, x_4, x_5, x_178);
-if (lean_obj_tag(x_199) == 0)
+lean_object* x_198; uint8_t x_199; lean_object* x_200; lean_object* x_201; 
+lean_dec(x_181);
+x_198 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__2;
+x_199 = 0;
+x_200 = l_Lean_Meta_Simp_rewriteCtorEq_x3f___closed__3;
+x_201 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_isPerm___spec__1___rarg(x_198, x_199, x_1, x_200, x_171, x_3, x_4, x_5, x_180);
+if (lean_obj_tag(x_201) == 0)
 {
-lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; 
-x_200 = lean_ctor_get(x_199, 0);
-lean_inc(x_200);
-x_201 = lean_ctor_get(x_199, 1);
-lean_inc(x_201);
-if (lean_is_exclusive(x_199)) {
- lean_ctor_release(x_199, 0);
- lean_ctor_release(x_199, 1);
- x_202 = x_199;
+lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; 
+x_202 = lean_ctor_get(x_201, 0);
+lean_inc(x_202);
+x_203 = lean_ctor_get(x_201, 1);
+lean_inc(x_203);
+if (lean_is_exclusive(x_201)) {
+ lean_ctor_release(x_201, 0);
+ lean_ctor_release(x_201, 1);
+ x_204 = x_201;
 } else {
- lean_dec_ref(x_199);
- x_202 = lean_box(0);
+ lean_dec_ref(x_201);
+ x_204 = lean_box(0);
 }
-if (lean_is_scalar(x_202)) {
- x_203 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_204)) {
+ x_205 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_203 = x_202;
+ x_205 = x_204;
 }
-lean_ctor_set(x_203, 0, x_200);
-lean_ctor_set(x_203, 1, x_201);
-return x_203;
+lean_ctor_set(x_205, 0, x_202);
+lean_ctor_set(x_205, 1, x_203);
+return x_205;
 }
 else
 {
-lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; 
-x_204 = lean_ctor_get(x_199, 0);
-lean_inc(x_204);
-x_205 = lean_ctor_get(x_199, 1);
-lean_inc(x_205);
-if (lean_is_exclusive(x_199)) {
- lean_ctor_release(x_199, 0);
- lean_ctor_release(x_199, 1);
- x_206 = x_199;
+lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; 
+x_206 = lean_ctor_get(x_201, 0);
+lean_inc(x_206);
+x_207 = lean_ctor_get(x_201, 1);
+lean_inc(x_207);
+if (lean_is_exclusive(x_201)) {
+ lean_ctor_release(x_201, 0);
+ lean_ctor_release(x_201, 1);
+ x_208 = x_201;
 } else {
- lean_dec_ref(x_199);
- x_206 = lean_box(0);
+ lean_dec_ref(x_201);
+ x_208 = lean_box(0);
 }
-if (lean_is_scalar(x_206)) {
- x_207 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_208)) {
+ x_209 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_207 = x_206;
+ x_209 = x_208;
 }
-lean_ctor_set(x_207, 0, x_204);
-lean_ctor_set(x_207, 1, x_205);
-return x_207;
-}
-}
-else
-{
-lean_object* x_208; lean_object* x_209; 
-lean_dec(x_169);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_208 = lean_box(0);
-if (lean_is_scalar(x_179)) {
- x_209 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_209 = x_179;
-}
-lean_ctor_set(x_209, 0, x_208);
-lean_ctor_set(x_209, 1, x_178);
+lean_ctor_set(x_209, 0, x_206);
+lean_ctor_set(x_209, 1, x_207);
 return x_209;
 }
 }
-}
-}
 else
 {
-lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; 
+lean_object* x_210; lean_object* x_211; 
 lean_dec(x_171);
-lean_dec(x_169);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_210 = lean_ctor_get(x_173, 0);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_173, 1);
-lean_inc(x_211);
-if (lean_is_exclusive(x_173)) {
- lean_ctor_release(x_173, 0);
- lean_ctor_release(x_173, 1);
- x_212 = x_173;
+x_210 = lean_box(0);
+if (lean_is_scalar(x_181)) {
+ x_211 = lean_alloc_ctor(0, 2, 0);
 } else {
- lean_dec_ref(x_173);
- x_212 = lean_box(0);
+ x_211 = x_181;
+}
+lean_ctor_set(x_211, 0, x_210);
+lean_ctor_set(x_211, 1, x_180);
+return x_211;
 }
-if (lean_is_scalar(x_212)) {
- x_213 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_213 = x_212;
 }
-lean_ctor_set(x_213, 0, x_210);
-lean_ctor_set(x_213, 1, x_211);
-return x_213;
 }
 }
 else
 {
-lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; 
-lean_dec(x_169);
+lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; 
+lean_dec(x_173);
+lean_dec(x_171);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_212 = lean_ctor_get(x_175, 0);
+lean_inc(x_212);
+x_213 = lean_ctor_get(x_175, 1);
+lean_inc(x_213);
+if (lean_is_exclusive(x_175)) {
+ lean_ctor_release(x_175, 0);
+ lean_ctor_release(x_175, 1);
+ x_214 = x_175;
+} else {
+ lean_dec_ref(x_175);
+ x_214 = lean_box(0);
+}
+if (lean_is_scalar(x_214)) {
+ x_215 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_215 = x_214;
+}
+lean_ctor_set(x_215, 0, x_212);
+lean_ctor_set(x_215, 1, x_213);
+return x_215;
+}
+}
+else
+{
+lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; 
+lean_dec(x_171);
 lean_dec(x_14);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_214 = lean_ctor_get(x_170, 0);
-lean_inc(x_214);
-x_215 = lean_ctor_get(x_170, 1);
-lean_inc(x_215);
-if (lean_is_exclusive(x_170)) {
- lean_ctor_release(x_170, 0);
- lean_ctor_release(x_170, 1);
- x_216 = x_170;
+x_216 = lean_ctor_get(x_172, 0);
+lean_inc(x_216);
+x_217 = lean_ctor_get(x_172, 1);
+lean_inc(x_217);
+if (lean_is_exclusive(x_172)) {
+ lean_ctor_release(x_172, 0);
+ lean_ctor_release(x_172, 1);
+ x_218 = x_172;
 } else {
- lean_dec_ref(x_170);
- x_216 = lean_box(0);
+ lean_dec_ref(x_172);
+ x_218 = lean_box(0);
 }
-if (lean_is_scalar(x_216)) {
- x_217 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_218)) {
+ x_219 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_217 = x_216;
+ x_219 = x_218;
 }
-lean_ctor_set(x_217, 0, x_214);
-lean_ctor_set(x_217, 1, x_215);
-return x_217;
+lean_ctor_set(x_219, 0, x_216);
+lean_ctor_set(x_219, 1, x_217);
+return x_219;
 }
 }
 }
@@ -6871,7 +6875,7 @@ x_14 = lean_ctor_get(x_2, 0);
 x_15 = !lean_is_exclusive(x_14);
 if (x_15 == 0)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; 
+lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; 
 x_16 = lean_ctor_get(x_2, 1);
 x_17 = lean_ctor_get(x_2, 2);
 x_18 = lean_ctor_get(x_2, 3);
@@ -6883,8 +6887,9 @@ x_23 = lean_ctor_get_uint8(x_14, 4);
 x_24 = lean_ctor_get_uint8(x_14, 6);
 x_25 = lean_ctor_get_uint8(x_14, 7);
 x_26 = lean_ctor_get_uint8(x_14, 8);
-x_27 = 3;
-lean_ctor_set_uint8(x_14, 5, x_27);
+x_27 = lean_ctor_get_uint8(x_14, 9);
+x_28 = 3;
+lean_ctor_set_uint8(x_14, 5, x_28);
 lean_inc(x_18);
 lean_inc(x_17);
 lean_inc(x_16);
@@ -6893,566 +6898,567 @@ lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
 lean_inc(x_1);
-x_28 = l_Lean_Meta_mkDecide(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_28) == 0)
+x_29 = l_Lean_Meta_mkDecide(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_29 = lean_ctor_get(x_28, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_28, 1);
+lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
-lean_dec(x_28);
-x_31 = 1;
-x_32 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_32, 0, x_19);
-lean_ctor_set_uint8(x_32, 1, x_20);
-lean_ctor_set_uint8(x_32, 2, x_21);
-lean_ctor_set_uint8(x_32, 3, x_22);
-lean_ctor_set_uint8(x_32, 4, x_23);
-lean_ctor_set_uint8(x_32, 5, x_31);
-lean_ctor_set_uint8(x_32, 6, x_24);
-lean_ctor_set_uint8(x_32, 7, x_25);
-lean_ctor_set_uint8(x_32, 8, x_26);
-x_33 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_16);
-lean_ctor_set(x_33, 2, x_17);
-lean_ctor_set(x_33, 3, x_18);
+x_31 = lean_ctor_get(x_29, 1);
+lean_inc(x_31);
+lean_dec(x_29);
+x_32 = 1;
+x_33 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_33, 0, x_19);
+lean_ctor_set_uint8(x_33, 1, x_20);
+lean_ctor_set_uint8(x_33, 2, x_21);
+lean_ctor_set_uint8(x_33, 3, x_22);
+lean_ctor_set_uint8(x_33, 4, x_23);
+lean_ctor_set_uint8(x_33, 5, x_32);
+lean_ctor_set_uint8(x_33, 6, x_24);
+lean_ctor_set_uint8(x_33, 7, x_25);
+lean_ctor_set_uint8(x_33, 8, x_26);
+lean_ctor_set_uint8(x_33, 9, x_27);
+x_34 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_34, 0, x_33);
+lean_ctor_set(x_34, 1, x_16);
+lean_ctor_set(x_34, 2, x_17);
+lean_ctor_set(x_34, 3, x_18);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_29);
-x_34 = l_Lean_Meta_whnf(x_29, x_33, x_3, x_4, x_5, x_30);
-if (lean_obj_tag(x_34) == 0)
+lean_inc(x_30);
+x_35 = l_Lean_Meta_whnf(x_30, x_34, x_3, x_4, x_5, x_31);
+if (lean_obj_tag(x_35) == 0)
 {
-uint8_t x_35; 
-x_35 = !lean_is_exclusive(x_34);
-if (x_35 == 0)
+uint8_t x_36; 
+x_36 = !lean_is_exclusive(x_35);
+if (x_36 == 0)
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_36 = lean_ctor_get(x_34, 0);
-x_37 = lean_ctor_get(x_34, 1);
-x_38 = l_Lean_instQuoteBool___closed__5;
-x_39 = l_Lean_Expr_isConstOf(x_36, x_38);
-if (x_39 == 0)
+lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; 
+x_37 = lean_ctor_get(x_35, 0);
+x_38 = lean_ctor_get(x_35, 1);
+x_39 = l_Lean_instQuoteBool___closed__5;
+x_40 = l_Lean_Expr_isConstOf(x_37, x_39);
+if (x_40 == 0)
 {
-lean_object* x_40; uint8_t x_41; 
-x_40 = l_Lean_instQuoteBool___closed__3;
-x_41 = l_Lean_Expr_isConstOf(x_36, x_40);
-lean_dec(x_36);
-if (x_41 == 0)
-{
-lean_object* x_42; 
-lean_dec(x_29);
-lean_dec(x_2);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_42 = lean_box(0);
-lean_ctor_set(x_34, 0, x_42);
-return x_34;
-}
-else
+lean_object* x_41; uint8_t x_42; 
+x_41 = l_Lean_instQuoteBool___closed__3;
+x_42 = l_Lean_Expr_isConstOf(x_37, x_41);
+lean_dec(x_37);
+if (x_42 == 0)
 {
 lean_object* x_43; 
-lean_free_object(x_34);
+lean_dec(x_30);
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_43 = lean_box(0);
+lean_ctor_set(x_35, 0, x_43);
+return x_35;
+}
+else
+{
+lean_object* x_44; 
+lean_free_object(x_35);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-lean_inc(x_29);
-x_43 = l_Lean_Meta_mkEqRefl(x_29, x_2, x_3, x_4, x_5, x_37);
-if (lean_obj_tag(x_43) == 0)
+lean_inc(x_30);
+x_44 = l_Lean_Meta_mkEqRefl(x_30, x_2, x_3, x_4, x_5, x_38);
+if (lean_obj_tag(x_44) == 0)
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_44 = lean_ctor_get(x_43, 1);
-lean_inc(x_44);
-lean_dec(x_43);
-x_45 = l_Lean_instToExprBool___lambda__1___closed__1;
-x_46 = l_Lean_Meta_mkEqRefl(x_45, x_2, x_3, x_4, x_5, x_44);
-if (lean_obj_tag(x_46) == 0)
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l_Lean_instToExprBool___lambda__1___closed__1;
+x_47 = l_Lean_Meta_mkEqRefl(x_46, x_2, x_3, x_4, x_5, x_45);
+if (lean_obj_tag(x_47) == 0)
 {
-uint8_t x_47; 
-x_47 = !lean_is_exclusive(x_46);
-if (x_47 == 0)
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_47);
+if (x_48 == 0)
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_48 = lean_ctor_get(x_46, 0);
-x_49 = l_Lean_Expr_appArg_x21(x_29);
-lean_dec(x_29);
-x_50 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_51 = lean_array_push(x_50, x_1);
-x_52 = lean_array_push(x_51, x_49);
-x_53 = lean_array_push(x_52, x_48);
-x_54 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
-x_55 = l_Lean_mkAppN(x_54, x_53);
-lean_dec(x_53);
-x_56 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_56, 0, x_55);
-x_57 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
-x_58 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set(x_58, 1, x_56);
-x_59 = lean_alloc_ctor(1, 1, 0);
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_49 = lean_ctor_get(x_47, 0);
+x_50 = l_Lean_Expr_appArg_x21(x_30);
+lean_dec(x_30);
+x_51 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_52 = lean_array_push(x_51, x_1);
+x_53 = lean_array_push(x_52, x_50);
+x_54 = lean_array_push(x_53, x_49);
+x_55 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
+x_56 = l_Lean_mkAppN(x_55, x_54);
+lean_dec(x_54);
+x_57 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_57, 0, x_56);
+x_58 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
+x_59 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_59, 0, x_58);
-lean_ctor_set(x_46, 0, x_59);
-return x_46;
+lean_ctor_set(x_59, 1, x_57);
+x_60 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_60, 0, x_59);
+lean_ctor_set(x_47, 0, x_60);
+return x_47;
 }
 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; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_60 = lean_ctor_get(x_46, 0);
-x_61 = lean_ctor_get(x_46, 1);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+x_61 = lean_ctor_get(x_47, 0);
+x_62 = lean_ctor_get(x_47, 1);
+lean_inc(x_62);
 lean_inc(x_61);
-lean_inc(x_60);
-lean_dec(x_46);
-x_62 = l_Lean_Expr_appArg_x21(x_29);
-lean_dec(x_29);
-x_63 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_64 = lean_array_push(x_63, x_1);
-x_65 = lean_array_push(x_64, x_62);
-x_66 = lean_array_push(x_65, x_60);
-x_67 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
-x_68 = l_Lean_mkAppN(x_67, x_66);
-lean_dec(x_66);
-x_69 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_69, 0, x_68);
-x_70 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
-x_71 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_71, 1, x_69);
-x_72 = lean_alloc_ctor(1, 1, 0);
+lean_dec(x_47);
+x_63 = l_Lean_Expr_appArg_x21(x_30);
+lean_dec(x_30);
+x_64 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_65 = lean_array_push(x_64, x_1);
+x_66 = lean_array_push(x_65, x_63);
+x_67 = lean_array_push(x_66, x_61);
+x_68 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
+x_69 = l_Lean_mkAppN(x_68, x_67);
+lean_dec(x_67);
+x_70 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_70, 0, x_69);
+x_71 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
+x_72 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_72, 0, x_71);
-x_73 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_72, 1, x_70);
+x_73 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_73, 0, x_72);
-lean_ctor_set(x_73, 1, x_61);
-return x_73;
+x_74 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_74, 0, x_73);
+lean_ctor_set(x_74, 1, x_62);
+return x_74;
 }
 }
 else
 {
-uint8_t x_74; 
-lean_dec(x_29);
+uint8_t x_75; 
+lean_dec(x_30);
 lean_dec(x_1);
-x_74 = !lean_is_exclusive(x_46);
-if (x_74 == 0)
+x_75 = !lean_is_exclusive(x_47);
+if (x_75 == 0)
 {
-lean_object* x_75; lean_object* x_76; 
-x_75 = lean_ctor_get(x_46, 0);
-lean_dec(x_75);
-x_76 = lean_box(0);
-lean_ctor_set_tag(x_46, 0);
-lean_ctor_set(x_46, 0, x_76);
-return x_46;
+lean_object* x_76; lean_object* x_77; 
+x_76 = lean_ctor_get(x_47, 0);
+lean_dec(x_76);
+x_77 = lean_box(0);
+lean_ctor_set_tag(x_47, 0);
+lean_ctor_set(x_47, 0, x_77);
+return x_47;
 }
 else
 {
-lean_object* x_77; lean_object* x_78; lean_object* x_79; 
-x_77 = lean_ctor_get(x_46, 1);
-lean_inc(x_77);
-lean_dec(x_46);
-x_78 = lean_box(0);
-x_79 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_79, 0, x_78);
-lean_ctor_set(x_79, 1, x_77);
-return x_79;
+lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+x_78 = lean_ctor_get(x_47, 1);
+lean_inc(x_78);
+lean_dec(x_47);
+x_79 = lean_box(0);
+x_80 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_80, 0, x_79);
+lean_ctor_set(x_80, 1, x_78);
+return x_80;
 }
 }
 }
 else
 {
-uint8_t x_80; 
-lean_dec(x_29);
+uint8_t x_81; 
+lean_dec(x_30);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_80 = !lean_is_exclusive(x_43);
-if (x_80 == 0)
+x_81 = !lean_is_exclusive(x_44);
+if (x_81 == 0)
 {
-lean_object* x_81; lean_object* x_82; 
-x_81 = lean_ctor_get(x_43, 0);
-lean_dec(x_81);
-x_82 = lean_box(0);
-lean_ctor_set_tag(x_43, 0);
-lean_ctor_set(x_43, 0, x_82);
-return x_43;
+lean_object* x_82; lean_object* x_83; 
+x_82 = lean_ctor_get(x_44, 0);
+lean_dec(x_82);
+x_83 = lean_box(0);
+lean_ctor_set_tag(x_44, 0);
+lean_ctor_set(x_44, 0, x_83);
+return x_44;
 }
 else
 {
-lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_83 = lean_ctor_get(x_43, 1);
-lean_inc(x_83);
-lean_dec(x_43);
-x_84 = lean_box(0);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_83);
-return x_85;
+lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+x_84 = lean_ctor_get(x_44, 1);
+lean_inc(x_84);
+lean_dec(x_44);
+x_85 = lean_box(0);
+x_86 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_86, 0, x_85);
+lean_ctor_set(x_86, 1, x_84);
+return x_86;
 }
 }
 }
 }
 else
 {
-lean_object* x_86; lean_object* x_87; 
-lean_free_object(x_34);
-lean_dec(x_36);
-x_86 = l_Lean_instToExprBool___lambda__1___closed__2;
-x_87 = l_Lean_Meta_mkEqRefl(x_86, x_2, x_3, x_4, x_5, x_37);
-if (lean_obj_tag(x_87) == 0)
+lean_object* x_87; lean_object* x_88; 
+lean_free_object(x_35);
+lean_dec(x_37);
+x_87 = l_Lean_instToExprBool___lambda__1___closed__2;
+x_88 = l_Lean_Meta_mkEqRefl(x_87, x_2, x_3, x_4, x_5, x_38);
+if (lean_obj_tag(x_88) == 0)
 {
-uint8_t x_88; 
-x_88 = !lean_is_exclusive(x_87);
-if (x_88 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_88);
+if (x_89 == 0)
 {
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 
-x_89 = lean_ctor_get(x_87, 0);
-x_90 = l_Lean_Expr_appArg_x21(x_29);
-lean_dec(x_29);
-x_91 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_92 = lean_array_push(x_91, x_1);
-x_93 = lean_array_push(x_92, x_90);
-x_94 = lean_array_push(x_93, x_89);
-x_95 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
-x_96 = l_Lean_mkAppN(x_95, x_94);
-lean_dec(x_94);
-x_97 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_97, 0, x_96);
-x_98 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
-x_99 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_99, 0, x_98);
-lean_ctor_set(x_99, 1, x_97);
-x_100 = lean_alloc_ctor(1, 1, 0);
+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; 
+x_90 = lean_ctor_get(x_88, 0);
+x_91 = l_Lean_Expr_appArg_x21(x_30);
+lean_dec(x_30);
+x_92 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_93 = lean_array_push(x_92, x_1);
+x_94 = lean_array_push(x_93, x_91);
+x_95 = lean_array_push(x_94, x_90);
+x_96 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
+x_97 = l_Lean_mkAppN(x_96, x_95);
+lean_dec(x_95);
+x_98 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_98, 0, x_97);
+x_99 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
+x_100 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_100, 0, x_99);
-lean_ctor_set(x_87, 0, x_100);
-return x_87;
+lean_ctor_set(x_100, 1, x_98);
+x_101 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_101, 0, x_100);
+lean_ctor_set(x_88, 0, x_101);
+return x_88;
 }
 else
 {
-lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; 
-x_101 = lean_ctor_get(x_87, 0);
-x_102 = lean_ctor_get(x_87, 1);
+lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+x_102 = lean_ctor_get(x_88, 0);
+x_103 = lean_ctor_get(x_88, 1);
+lean_inc(x_103);
 lean_inc(x_102);
-lean_inc(x_101);
-lean_dec(x_87);
-x_103 = l_Lean_Expr_appArg_x21(x_29);
-lean_dec(x_29);
-x_104 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_105 = lean_array_push(x_104, x_1);
-x_106 = lean_array_push(x_105, x_103);
-x_107 = lean_array_push(x_106, x_101);
-x_108 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
-x_109 = l_Lean_mkAppN(x_108, x_107);
-lean_dec(x_107);
-x_110 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_110, 0, x_109);
-x_111 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
-x_112 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_112, 0, x_111);
-lean_ctor_set(x_112, 1, x_110);
-x_113 = lean_alloc_ctor(1, 1, 0);
+lean_dec(x_88);
+x_104 = l_Lean_Expr_appArg_x21(x_30);
+lean_dec(x_30);
+x_105 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_106 = lean_array_push(x_105, x_1);
+x_107 = lean_array_push(x_106, x_104);
+x_108 = lean_array_push(x_107, x_102);
+x_109 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
+x_110 = l_Lean_mkAppN(x_109, x_108);
+lean_dec(x_108);
+x_111 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_111, 0, x_110);
+x_112 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
+x_113 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_113, 0, x_112);
-x_114 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_113, 1, x_111);
+x_114 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_114, 0, x_113);
-lean_ctor_set(x_114, 1, x_102);
-return x_114;
+x_115 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_115, 0, x_114);
+lean_ctor_set(x_115, 1, x_103);
+return x_115;
 }
 }
 else
 {
-uint8_t x_115; 
-lean_dec(x_29);
+uint8_t x_116; 
+lean_dec(x_30);
 lean_dec(x_1);
-x_115 = !lean_is_exclusive(x_87);
-if (x_115 == 0)
+x_116 = !lean_is_exclusive(x_88);
+if (x_116 == 0)
 {
-lean_object* x_116; lean_object* x_117; 
-x_116 = lean_ctor_get(x_87, 0);
-lean_dec(x_116);
-x_117 = lean_box(0);
-lean_ctor_set_tag(x_87, 0);
-lean_ctor_set(x_87, 0, x_117);
-return x_87;
+lean_object* x_117; lean_object* x_118; 
+x_117 = lean_ctor_get(x_88, 0);
+lean_dec(x_117);
+x_118 = lean_box(0);
+lean_ctor_set_tag(x_88, 0);
+lean_ctor_set(x_88, 0, x_118);
+return x_88;
 }
 else
 {
-lean_object* x_118; lean_object* x_119; lean_object* x_120; 
-x_118 = lean_ctor_get(x_87, 1);
-lean_inc(x_118);
-lean_dec(x_87);
-x_119 = lean_box(0);
-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;
+lean_object* x_119; lean_object* x_120; lean_object* x_121; 
+x_119 = lean_ctor_get(x_88, 1);
+lean_inc(x_119);
+lean_dec(x_88);
+x_120 = lean_box(0);
+x_121 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_121, 0, x_120);
+lean_ctor_set(x_121, 1, x_119);
+return x_121;
 }
 }
 }
 }
 else
 {
-lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_121 = lean_ctor_get(x_34, 0);
-x_122 = lean_ctor_get(x_34, 1);
+lean_object* x_122; lean_object* x_123; lean_object* x_124; uint8_t x_125; 
+x_122 = lean_ctor_get(x_35, 0);
+x_123 = lean_ctor_get(x_35, 1);
+lean_inc(x_123);
 lean_inc(x_122);
-lean_inc(x_121);
-lean_dec(x_34);
-x_123 = l_Lean_instQuoteBool___closed__5;
-x_124 = l_Lean_Expr_isConstOf(x_121, x_123);
-if (x_124 == 0)
+lean_dec(x_35);
+x_124 = l_Lean_instQuoteBool___closed__5;
+x_125 = l_Lean_Expr_isConstOf(x_122, x_124);
+if (x_125 == 0)
 {
-lean_object* x_125; uint8_t x_126; 
-x_125 = l_Lean_instQuoteBool___closed__3;
-x_126 = l_Lean_Expr_isConstOf(x_121, x_125);
-lean_dec(x_121);
-if (x_126 == 0)
+lean_object* x_126; uint8_t x_127; 
+x_126 = l_Lean_instQuoteBool___closed__3;
+x_127 = l_Lean_Expr_isConstOf(x_122, x_126);
+lean_dec(x_122);
+if (x_127 == 0)
 {
-lean_object* x_127; lean_object* x_128; 
-lean_dec(x_29);
+lean_object* x_128; lean_object* x_129; 
+lean_dec(x_30);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_127 = lean_box(0);
-x_128 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_128, 0, x_127);
-lean_ctor_set(x_128, 1, x_122);
-return x_128;
+x_128 = lean_box(0);
+x_129 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_129, 0, x_128);
+lean_ctor_set(x_129, 1, x_123);
+return x_129;
 }
 else
 {
-lean_object* x_129; 
+lean_object* x_130; 
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-lean_inc(x_29);
-x_129 = l_Lean_Meta_mkEqRefl(x_29, x_2, x_3, x_4, x_5, x_122);
-if (lean_obj_tag(x_129) == 0)
+lean_inc(x_30);
+x_130 = l_Lean_Meta_mkEqRefl(x_30, x_2, x_3, x_4, x_5, x_123);
+if (lean_obj_tag(x_130) == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; 
-x_130 = lean_ctor_get(x_129, 1);
-lean_inc(x_130);
-lean_dec(x_129);
-x_131 = l_Lean_instToExprBool___lambda__1___closed__1;
-x_132 = l_Lean_Meta_mkEqRefl(x_131, x_2, x_3, x_4, x_5, x_130);
-if (lean_obj_tag(x_132) == 0)
+lean_object* x_131; lean_object* x_132; lean_object* x_133; 
+x_131 = lean_ctor_get(x_130, 1);
+lean_inc(x_131);
+lean_dec(x_130);
+x_132 = l_Lean_instToExprBool___lambda__1___closed__1;
+x_133 = l_Lean_Meta_mkEqRefl(x_132, x_2, x_3, x_4, x_5, x_131);
+if (lean_obj_tag(x_133) == 0)
 {
-lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; 
-x_133 = lean_ctor_get(x_132, 0);
-lean_inc(x_133);
-x_134 = lean_ctor_get(x_132, 1);
+lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; 
+x_134 = lean_ctor_get(x_133, 0);
 lean_inc(x_134);
-if (lean_is_exclusive(x_132)) {
- lean_ctor_release(x_132, 0);
- lean_ctor_release(x_132, 1);
- x_135 = x_132;
+x_135 = lean_ctor_get(x_133, 1);
+lean_inc(x_135);
+if (lean_is_exclusive(x_133)) {
+ lean_ctor_release(x_133, 0);
+ lean_ctor_release(x_133, 1);
+ x_136 = x_133;
 } else {
- lean_dec_ref(x_132);
- x_135 = lean_box(0);
+ lean_dec_ref(x_133);
+ x_136 = lean_box(0);
 }
-x_136 = l_Lean_Expr_appArg_x21(x_29);
-lean_dec(x_29);
-x_137 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_138 = lean_array_push(x_137, x_1);
-x_139 = lean_array_push(x_138, x_136);
-x_140 = lean_array_push(x_139, x_133);
-x_141 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
-x_142 = l_Lean_mkAppN(x_141, x_140);
-lean_dec(x_140);
-x_143 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_143, 0, x_142);
-x_144 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
-x_145 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_145, 0, x_144);
-lean_ctor_set(x_145, 1, x_143);
-x_146 = lean_alloc_ctor(1, 1, 0);
+x_137 = l_Lean_Expr_appArg_x21(x_30);
+lean_dec(x_30);
+x_138 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_139 = lean_array_push(x_138, x_1);
+x_140 = lean_array_push(x_139, x_137);
+x_141 = lean_array_push(x_140, x_134);
+x_142 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
+x_143 = l_Lean_mkAppN(x_142, x_141);
+lean_dec(x_141);
+x_144 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_144, 0, x_143);
+x_145 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
+x_146 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_146, 0, x_145);
-if (lean_is_scalar(x_135)) {
- x_147 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_147 = x_135;
-}
+lean_ctor_set(x_146, 1, x_144);
+x_147 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_147, 0, x_146);
-lean_ctor_set(x_147, 1, x_134);
-return x_147;
+if (lean_is_scalar(x_136)) {
+ x_148 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_148 = x_136;
+}
+lean_ctor_set(x_148, 0, x_147);
+lean_ctor_set(x_148, 1, x_135);
+return x_148;
 }
 else
 {
-lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
-lean_dec(x_29);
+lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
+lean_dec(x_30);
 lean_dec(x_1);
-x_148 = lean_ctor_get(x_132, 1);
-lean_inc(x_148);
-if (lean_is_exclusive(x_132)) {
- lean_ctor_release(x_132, 0);
- lean_ctor_release(x_132, 1);
- x_149 = x_132;
+x_149 = lean_ctor_get(x_133, 1);
+lean_inc(x_149);
+if (lean_is_exclusive(x_133)) {
+ lean_ctor_release(x_133, 0);
+ lean_ctor_release(x_133, 1);
+ x_150 = x_133;
 } else {
- lean_dec_ref(x_132);
- x_149 = lean_box(0);
+ lean_dec_ref(x_133);
+ x_150 = lean_box(0);
 }
-x_150 = lean_box(0);
-if (lean_is_scalar(x_149)) {
- x_151 = lean_alloc_ctor(0, 2, 0);
+x_151 = lean_box(0);
+if (lean_is_scalar(x_150)) {
+ x_152 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_151 = x_149;
- lean_ctor_set_tag(x_151, 0);
+ x_152 = x_150;
+ lean_ctor_set_tag(x_152, 0);
 }
-lean_ctor_set(x_151, 0, x_150);
-lean_ctor_set(x_151, 1, x_148);
-return x_151;
+lean_ctor_set(x_152, 0, x_151);
+lean_ctor_set(x_152, 1, x_149);
+return x_152;
 }
 }
 else
 {
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; 
-lean_dec(x_29);
+lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; 
+lean_dec(x_30);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_152 = lean_ctor_get(x_129, 1);
-lean_inc(x_152);
-if (lean_is_exclusive(x_129)) {
- lean_ctor_release(x_129, 0);
- lean_ctor_release(x_129, 1);
- x_153 = x_129;
+x_153 = lean_ctor_get(x_130, 1);
+lean_inc(x_153);
+if (lean_is_exclusive(x_130)) {
+ lean_ctor_release(x_130, 0);
+ lean_ctor_release(x_130, 1);
+ x_154 = x_130;
 } else {
- lean_dec_ref(x_129);
- x_153 = lean_box(0);
+ lean_dec_ref(x_130);
+ x_154 = lean_box(0);
 }
-x_154 = lean_box(0);
-if (lean_is_scalar(x_153)) {
- x_155 = lean_alloc_ctor(0, 2, 0);
+x_155 = lean_box(0);
+if (lean_is_scalar(x_154)) {
+ x_156 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_155 = x_153;
- lean_ctor_set_tag(x_155, 0);
+ x_156 = x_154;
+ lean_ctor_set_tag(x_156, 0);
 }
-lean_ctor_set(x_155, 0, x_154);
-lean_ctor_set(x_155, 1, x_152);
-return x_155;
+lean_ctor_set(x_156, 0, x_155);
+lean_ctor_set(x_156, 1, x_153);
+return x_156;
 }
 }
 }
 else
 {
-lean_object* x_156; lean_object* x_157; 
-lean_dec(x_121);
-x_156 = l_Lean_instToExprBool___lambda__1___closed__2;
-x_157 = l_Lean_Meta_mkEqRefl(x_156, x_2, x_3, x_4, x_5, x_122);
-if (lean_obj_tag(x_157) == 0)
+lean_object* x_157; lean_object* x_158; 
+lean_dec(x_122);
+x_157 = l_Lean_instToExprBool___lambda__1___closed__2;
+x_158 = l_Lean_Meta_mkEqRefl(x_157, x_2, x_3, x_4, x_5, x_123);
+if (lean_obj_tag(x_158) == 0)
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; 
-x_158 = lean_ctor_get(x_157, 0);
-lean_inc(x_158);
-x_159 = lean_ctor_get(x_157, 1);
+lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; 
+x_159 = lean_ctor_get(x_158, 0);
 lean_inc(x_159);
-if (lean_is_exclusive(x_157)) {
- lean_ctor_release(x_157, 0);
- lean_ctor_release(x_157, 1);
- x_160 = x_157;
+x_160 = lean_ctor_get(x_158, 1);
+lean_inc(x_160);
+if (lean_is_exclusive(x_158)) {
+ lean_ctor_release(x_158, 0);
+ lean_ctor_release(x_158, 1);
+ x_161 = x_158;
 } else {
- lean_dec_ref(x_157);
- x_160 = lean_box(0);
+ lean_dec_ref(x_158);
+ x_161 = lean_box(0);
 }
-x_161 = l_Lean_Expr_appArg_x21(x_29);
-lean_dec(x_29);
-x_162 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_163 = lean_array_push(x_162, x_1);
-x_164 = lean_array_push(x_163, x_161);
-x_165 = lean_array_push(x_164, x_158);
-x_166 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
-x_167 = l_Lean_mkAppN(x_166, x_165);
-lean_dec(x_165);
-x_168 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_168, 0, x_167);
-x_169 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
-x_170 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_170, 0, x_169);
-lean_ctor_set(x_170, 1, x_168);
-x_171 = lean_alloc_ctor(1, 1, 0);
+x_162 = l_Lean_Expr_appArg_x21(x_30);
+lean_dec(x_30);
+x_163 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_164 = lean_array_push(x_163, x_1);
+x_165 = lean_array_push(x_164, x_162);
+x_166 = lean_array_push(x_165, x_159);
+x_167 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
+x_168 = l_Lean_mkAppN(x_167, x_166);
+lean_dec(x_166);
+x_169 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_169, 0, x_168);
+x_170 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
+x_171 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_171, 0, x_170);
-if (lean_is_scalar(x_160)) {
- x_172 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_172 = x_160;
-}
+lean_ctor_set(x_171, 1, x_169);
+x_172 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_172, 0, x_171);
-lean_ctor_set(x_172, 1, x_159);
-return x_172;
+if (lean_is_scalar(x_161)) {
+ x_173 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_173 = x_161;
+}
+lean_ctor_set(x_173, 0, x_172);
+lean_ctor_set(x_173, 1, x_160);
+return x_173;
 }
 else
 {
-lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; 
-lean_dec(x_29);
+lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; 
+lean_dec(x_30);
 lean_dec(x_1);
-x_173 = lean_ctor_get(x_157, 1);
-lean_inc(x_173);
-if (lean_is_exclusive(x_157)) {
- lean_ctor_release(x_157, 0);
- lean_ctor_release(x_157, 1);
- x_174 = x_157;
+x_174 = lean_ctor_get(x_158, 1);
+lean_inc(x_174);
+if (lean_is_exclusive(x_158)) {
+ lean_ctor_release(x_158, 0);
+ lean_ctor_release(x_158, 1);
+ x_175 = x_158;
 } else {
- lean_dec_ref(x_157);
- x_174 = lean_box(0);
+ lean_dec_ref(x_158);
+ x_175 = lean_box(0);
 }
-x_175 = lean_box(0);
-if (lean_is_scalar(x_174)) {
- x_176 = lean_alloc_ctor(0, 2, 0);
+x_176 = lean_box(0);
+if (lean_is_scalar(x_175)) {
+ x_177 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_176 = x_174;
- lean_ctor_set_tag(x_176, 0);
+ x_177 = x_175;
+ lean_ctor_set_tag(x_177, 0);
 }
-lean_ctor_set(x_176, 0, x_175);
-lean_ctor_set(x_176, 1, x_173);
-return x_176;
+lean_ctor_set(x_177, 0, x_176);
+lean_ctor_set(x_177, 1, x_174);
+return x_177;
 }
 }
 }
 }
 else
 {
-uint8_t x_177; 
-lean_dec(x_29);
+uint8_t x_178; 
+lean_dec(x_30);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_177 = !lean_is_exclusive(x_34);
-if (x_177 == 0)
+x_178 = !lean_is_exclusive(x_35);
+if (x_178 == 0)
 {
-lean_object* x_178; lean_object* x_179; 
-x_178 = lean_ctor_get(x_34, 0);
-lean_dec(x_178);
-x_179 = lean_box(0);
-lean_ctor_set_tag(x_34, 0);
-lean_ctor_set(x_34, 0, x_179);
-return x_34;
+lean_object* x_179; lean_object* x_180; 
+x_179 = lean_ctor_get(x_35, 0);
+lean_dec(x_179);
+x_180 = lean_box(0);
+lean_ctor_set_tag(x_35, 0);
+lean_ctor_set(x_35, 0, x_180);
+return x_35;
 }
 else
 {
-lean_object* x_180; lean_object* x_181; lean_object* x_182; 
-x_180 = lean_ctor_get(x_34, 1);
-lean_inc(x_180);
-lean_dec(x_34);
-x_181 = lean_box(0);
-x_182 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_182, 0, x_181);
-lean_ctor_set(x_182, 1, x_180);
-return x_182;
+lean_object* x_181; lean_object* x_182; lean_object* x_183; 
+x_181 = lean_ctor_get(x_35, 1);
+lean_inc(x_181);
+lean_dec(x_35);
+x_182 = lean_box(0);
+x_183 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_183, 0, x_182);
+lean_ctor_set(x_183, 1, x_181);
+return x_183;
 }
 }
 }
 else
 {
-uint8_t x_183; 
+uint8_t x_184; 
 lean_dec(x_2);
 lean_dec(x_18);
 lean_dec(x_17);
@@ -7461,840 +7467,846 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_183 = !lean_is_exclusive(x_28);
-if (x_183 == 0)
+x_184 = !lean_is_exclusive(x_29);
+if (x_184 == 0)
 {
-lean_object* x_184; lean_object* x_185; 
-x_184 = lean_ctor_get(x_28, 0);
-lean_dec(x_184);
-x_185 = lean_box(0);
-lean_ctor_set_tag(x_28, 0);
-lean_ctor_set(x_28, 0, x_185);
-return x_28;
+lean_object* x_185; lean_object* x_186; 
+x_185 = lean_ctor_get(x_29, 0);
+lean_dec(x_185);
+x_186 = lean_box(0);
+lean_ctor_set_tag(x_29, 0);
+lean_ctor_set(x_29, 0, x_186);
+return x_29;
 }
 else
 {
-lean_object* x_186; lean_object* x_187; lean_object* x_188; 
-x_186 = lean_ctor_get(x_28, 1);
-lean_inc(x_186);
-lean_dec(x_28);
-x_187 = lean_box(0);
-x_188 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_188, 0, x_187);
-lean_ctor_set(x_188, 1, x_186);
-return x_188;
+lean_object* x_187; lean_object* x_188; lean_object* x_189; 
+x_187 = lean_ctor_get(x_29, 1);
+lean_inc(x_187);
+lean_dec(x_29);
+x_188 = lean_box(0);
+x_189 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_189, 0, x_188);
+lean_ctor_set(x_189, 1, x_187);
+return x_189;
 }
 }
 }
 else
 {
-lean_object* x_189; lean_object* x_190; lean_object* x_191; uint8_t x_192; uint8_t x_193; uint8_t x_194; uint8_t x_195; uint8_t x_196; uint8_t x_197; uint8_t x_198; uint8_t x_199; uint8_t x_200; lean_object* x_201; lean_object* x_202; 
-x_189 = lean_ctor_get(x_2, 1);
-x_190 = lean_ctor_get(x_2, 2);
-x_191 = lean_ctor_get(x_2, 3);
-x_192 = lean_ctor_get_uint8(x_14, 0);
-x_193 = lean_ctor_get_uint8(x_14, 1);
-x_194 = lean_ctor_get_uint8(x_14, 2);
-x_195 = lean_ctor_get_uint8(x_14, 3);
-x_196 = lean_ctor_get_uint8(x_14, 4);
-x_197 = lean_ctor_get_uint8(x_14, 6);
-x_198 = lean_ctor_get_uint8(x_14, 7);
-x_199 = lean_ctor_get_uint8(x_14, 8);
+lean_object* x_190; lean_object* x_191; lean_object* x_192; uint8_t x_193; uint8_t x_194; uint8_t x_195; uint8_t x_196; uint8_t x_197; uint8_t x_198; uint8_t x_199; uint8_t x_200; uint8_t x_201; uint8_t x_202; lean_object* x_203; lean_object* x_204; 
+x_190 = lean_ctor_get(x_2, 1);
+x_191 = lean_ctor_get(x_2, 2);
+x_192 = lean_ctor_get(x_2, 3);
+x_193 = lean_ctor_get_uint8(x_14, 0);
+x_194 = lean_ctor_get_uint8(x_14, 1);
+x_195 = lean_ctor_get_uint8(x_14, 2);
+x_196 = lean_ctor_get_uint8(x_14, 3);
+x_197 = lean_ctor_get_uint8(x_14, 4);
+x_198 = lean_ctor_get_uint8(x_14, 6);
+x_199 = lean_ctor_get_uint8(x_14, 7);
+x_200 = lean_ctor_get_uint8(x_14, 8);
+x_201 = lean_ctor_get_uint8(x_14, 9);
 lean_dec(x_14);
-x_200 = 3;
-x_201 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_201, 0, x_192);
-lean_ctor_set_uint8(x_201, 1, x_193);
-lean_ctor_set_uint8(x_201, 2, x_194);
-lean_ctor_set_uint8(x_201, 3, x_195);
-lean_ctor_set_uint8(x_201, 4, x_196);
-lean_ctor_set_uint8(x_201, 5, x_200);
-lean_ctor_set_uint8(x_201, 6, x_197);
-lean_ctor_set_uint8(x_201, 7, x_198);
-lean_ctor_set_uint8(x_201, 8, x_199);
+x_202 = 3;
+x_203 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_203, 0, x_193);
+lean_ctor_set_uint8(x_203, 1, x_194);
+lean_ctor_set_uint8(x_203, 2, x_195);
+lean_ctor_set_uint8(x_203, 3, x_196);
+lean_ctor_set_uint8(x_203, 4, x_197);
+lean_ctor_set_uint8(x_203, 5, x_202);
+lean_ctor_set_uint8(x_203, 6, x_198);
+lean_ctor_set_uint8(x_203, 7, x_199);
+lean_ctor_set_uint8(x_203, 8, x_200);
+lean_ctor_set_uint8(x_203, 9, x_201);
+lean_inc(x_192);
 lean_inc(x_191);
 lean_inc(x_190);
-lean_inc(x_189);
-lean_ctor_set(x_2, 0, x_201);
+lean_ctor_set(x_2, 0, x_203);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
 lean_inc(x_1);
-x_202 = l_Lean_Meta_mkDecide(x_1, x_2, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_202) == 0)
+x_204 = l_Lean_Meta_mkDecide(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_204) == 0)
 {
-lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; 
-x_203 = lean_ctor_get(x_202, 0);
-lean_inc(x_203);
-x_204 = lean_ctor_get(x_202, 1);
-lean_inc(x_204);
-lean_dec(x_202);
-x_205 = 1;
-x_206 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_206, 0, x_192);
-lean_ctor_set_uint8(x_206, 1, x_193);
-lean_ctor_set_uint8(x_206, 2, x_194);
-lean_ctor_set_uint8(x_206, 3, x_195);
-lean_ctor_set_uint8(x_206, 4, x_196);
-lean_ctor_set_uint8(x_206, 5, x_205);
-lean_ctor_set_uint8(x_206, 6, x_197);
-lean_ctor_set_uint8(x_206, 7, x_198);
-lean_ctor_set_uint8(x_206, 8, x_199);
-x_207 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_207, 0, x_206);
-lean_ctor_set(x_207, 1, x_189);
-lean_ctor_set(x_207, 2, x_190);
-lean_ctor_set(x_207, 3, x_191);
+lean_object* x_205; lean_object* x_206; uint8_t x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; 
+x_205 = lean_ctor_get(x_204, 0);
+lean_inc(x_205);
+x_206 = lean_ctor_get(x_204, 1);
+lean_inc(x_206);
+lean_dec(x_204);
+x_207 = 1;
+x_208 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_208, 0, x_193);
+lean_ctor_set_uint8(x_208, 1, x_194);
+lean_ctor_set_uint8(x_208, 2, x_195);
+lean_ctor_set_uint8(x_208, 3, x_196);
+lean_ctor_set_uint8(x_208, 4, x_197);
+lean_ctor_set_uint8(x_208, 5, x_207);
+lean_ctor_set_uint8(x_208, 6, x_198);
+lean_ctor_set_uint8(x_208, 7, x_199);
+lean_ctor_set_uint8(x_208, 8, x_200);
+lean_ctor_set_uint8(x_208, 9, x_201);
+x_209 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_209, 0, x_208);
+lean_ctor_set(x_209, 1, x_190);
+lean_ctor_set(x_209, 2, x_191);
+lean_ctor_set(x_209, 3, x_192);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_203);
-x_208 = l_Lean_Meta_whnf(x_203, x_207, x_3, x_4, x_5, x_204);
-if (lean_obj_tag(x_208) == 0)
+lean_inc(x_205);
+x_210 = l_Lean_Meta_whnf(x_205, x_209, x_3, x_4, x_5, x_206);
+if (lean_obj_tag(x_210) == 0)
 {
-lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; uint8_t x_213; 
-x_209 = lean_ctor_get(x_208, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_208, 1);
-lean_inc(x_210);
-if (lean_is_exclusive(x_208)) {
- lean_ctor_release(x_208, 0);
- lean_ctor_release(x_208, 1);
- x_211 = x_208;
+lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; uint8_t x_215; 
+x_211 = lean_ctor_get(x_210, 0);
+lean_inc(x_211);
+x_212 = lean_ctor_get(x_210, 1);
+lean_inc(x_212);
+if (lean_is_exclusive(x_210)) {
+ lean_ctor_release(x_210, 0);
+ lean_ctor_release(x_210, 1);
+ x_213 = x_210;
 } else {
- lean_dec_ref(x_208);
- x_211 = lean_box(0);
+ lean_dec_ref(x_210);
+ x_213 = lean_box(0);
 }
-x_212 = l_Lean_instQuoteBool___closed__5;
-x_213 = l_Lean_Expr_isConstOf(x_209, x_212);
-if (x_213 == 0)
-{
-lean_object* x_214; uint8_t x_215; 
-x_214 = l_Lean_instQuoteBool___closed__3;
-x_215 = l_Lean_Expr_isConstOf(x_209, x_214);
-lean_dec(x_209);
+x_214 = l_Lean_instQuoteBool___closed__5;
+x_215 = l_Lean_Expr_isConstOf(x_211, x_214);
 if (x_215 == 0)
 {
-lean_object* x_216; lean_object* x_217; 
-lean_dec(x_203);
+lean_object* x_216; uint8_t x_217; 
+x_216 = l_Lean_instQuoteBool___closed__3;
+x_217 = l_Lean_Expr_isConstOf(x_211, x_216);
+lean_dec(x_211);
+if (x_217 == 0)
+{
+lean_object* x_218; lean_object* x_219; 
+lean_dec(x_205);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_216 = lean_box(0);
-if (lean_is_scalar(x_211)) {
- x_217 = lean_alloc_ctor(0, 2, 0);
+x_218 = lean_box(0);
+if (lean_is_scalar(x_213)) {
+ x_219 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_217 = x_211;
+ x_219 = x_213;
 }
-lean_ctor_set(x_217, 0, x_216);
-lean_ctor_set(x_217, 1, x_210);
-return x_217;
+lean_ctor_set(x_219, 0, x_218);
+lean_ctor_set(x_219, 1, x_212);
+return x_219;
 }
 else
 {
-lean_object* x_218; 
-lean_dec(x_211);
+lean_object* x_220; 
+lean_dec(x_213);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
-lean_inc(x_203);
-x_218 = l_Lean_Meta_mkEqRefl(x_203, x_2, x_3, x_4, x_5, x_210);
-if (lean_obj_tag(x_218) == 0)
+lean_inc(x_205);
+x_220 = l_Lean_Meta_mkEqRefl(x_205, x_2, x_3, x_4, x_5, x_212);
+if (lean_obj_tag(x_220) == 0)
 {
-lean_object* x_219; lean_object* x_220; lean_object* x_221; 
-x_219 = lean_ctor_get(x_218, 1);
-lean_inc(x_219);
-lean_dec(x_218);
-x_220 = l_Lean_instToExprBool___lambda__1___closed__1;
-x_221 = l_Lean_Meta_mkEqRefl(x_220, x_2, x_3, x_4, x_5, x_219);
-if (lean_obj_tag(x_221) == 0)
+lean_object* x_221; lean_object* x_222; lean_object* x_223; 
+x_221 = lean_ctor_get(x_220, 1);
+lean_inc(x_221);
+lean_dec(x_220);
+x_222 = l_Lean_instToExprBool___lambda__1___closed__1;
+x_223 = l_Lean_Meta_mkEqRefl(x_222, x_2, x_3, x_4, x_5, x_221);
+if (lean_obj_tag(x_223) == 0)
 {
-lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; 
-x_222 = lean_ctor_get(x_221, 0);
-lean_inc(x_222);
-x_223 = lean_ctor_get(x_221, 1);
-lean_inc(x_223);
-if (lean_is_exclusive(x_221)) {
- lean_ctor_release(x_221, 0);
- lean_ctor_release(x_221, 1);
- x_224 = x_221;
+lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; 
+x_224 = lean_ctor_get(x_223, 0);
+lean_inc(x_224);
+x_225 = lean_ctor_get(x_223, 1);
+lean_inc(x_225);
+if (lean_is_exclusive(x_223)) {
+ lean_ctor_release(x_223, 0);
+ lean_ctor_release(x_223, 1);
+ x_226 = x_223;
 } else {
- lean_dec_ref(x_221);
- x_224 = lean_box(0);
+ lean_dec_ref(x_223);
+ x_226 = lean_box(0);
 }
-x_225 = l_Lean_Expr_appArg_x21(x_203);
-lean_dec(x_203);
-x_226 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_227 = lean_array_push(x_226, x_1);
-x_228 = lean_array_push(x_227, x_225);
-x_229 = lean_array_push(x_228, x_222);
-x_230 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
-x_231 = l_Lean_mkAppN(x_230, x_229);
-lean_dec(x_229);
-x_232 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_232, 0, x_231);
-x_233 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
-x_234 = lean_alloc_ctor(0, 2, 0);
+x_227 = l_Lean_Expr_appArg_x21(x_205);
+lean_dec(x_205);
+x_228 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_229 = lean_array_push(x_228, x_1);
+x_230 = lean_array_push(x_229, x_227);
+x_231 = lean_array_push(x_230, x_224);
+x_232 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
+x_233 = l_Lean_mkAppN(x_232, x_231);
+lean_dec(x_231);
+x_234 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_234, 0, x_233);
-lean_ctor_set(x_234, 1, x_232);
-x_235 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_235, 0, x_234);
-if (lean_is_scalar(x_224)) {
- x_236 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_236 = x_224;
-}
+x_235 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
+x_236 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_236, 0, x_235);
-lean_ctor_set(x_236, 1, x_223);
-return x_236;
+lean_ctor_set(x_236, 1, x_234);
+x_237 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_237, 0, x_236);
+if (lean_is_scalar(x_226)) {
+ x_238 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_238 = x_226;
+}
+lean_ctor_set(x_238, 0, x_237);
+lean_ctor_set(x_238, 1, x_225);
+return x_238;
 }
 else
 {
-lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; 
-lean_dec(x_203);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; 
+lean_dec(x_205);
 lean_dec(x_1);
-x_237 = lean_ctor_get(x_221, 1);
-lean_inc(x_237);
-if (lean_is_exclusive(x_221)) {
- lean_ctor_release(x_221, 0);
- lean_ctor_release(x_221, 1);
- x_238 = x_221;
+x_239 = lean_ctor_get(x_223, 1);
+lean_inc(x_239);
+if (lean_is_exclusive(x_223)) {
+ lean_ctor_release(x_223, 0);
+ lean_ctor_release(x_223, 1);
+ x_240 = x_223;
 } else {
- lean_dec_ref(x_221);
- x_238 = lean_box(0);
+ lean_dec_ref(x_223);
+ x_240 = lean_box(0);
 }
-x_239 = lean_box(0);
-if (lean_is_scalar(x_238)) {
- x_240 = lean_alloc_ctor(0, 2, 0);
+x_241 = lean_box(0);
+if (lean_is_scalar(x_240)) {
+ x_242 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_240 = x_238;
- lean_ctor_set_tag(x_240, 0);
+ x_242 = x_240;
+ lean_ctor_set_tag(x_242, 0);
 }
-lean_ctor_set(x_240, 0, x_239);
-lean_ctor_set(x_240, 1, x_237);
-return x_240;
+lean_ctor_set(x_242, 0, x_241);
+lean_ctor_set(x_242, 1, x_239);
+return x_242;
 }
 }
 else
 {
-lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; 
-lean_dec(x_203);
+lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; 
+lean_dec(x_205);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_241 = lean_ctor_get(x_218, 1);
-lean_inc(x_241);
-if (lean_is_exclusive(x_218)) {
- lean_ctor_release(x_218, 0);
- lean_ctor_release(x_218, 1);
- x_242 = x_218;
+x_243 = lean_ctor_get(x_220, 1);
+lean_inc(x_243);
+if (lean_is_exclusive(x_220)) {
+ lean_ctor_release(x_220, 0);
+ lean_ctor_release(x_220, 1);
+ x_244 = x_220;
 } else {
- lean_dec_ref(x_218);
- x_242 = lean_box(0);
+ lean_dec_ref(x_220);
+ x_244 = lean_box(0);
 }
-x_243 = lean_box(0);
-if (lean_is_scalar(x_242)) {
- x_244 = lean_alloc_ctor(0, 2, 0);
+x_245 = lean_box(0);
+if (lean_is_scalar(x_244)) {
+ x_246 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_244 = x_242;
- lean_ctor_set_tag(x_244, 0);
+ x_246 = x_244;
+ lean_ctor_set_tag(x_246, 0);
 }
-lean_ctor_set(x_244, 0, x_243);
-lean_ctor_set(x_244, 1, x_241);
-return x_244;
+lean_ctor_set(x_246, 0, x_245);
+lean_ctor_set(x_246, 1, x_243);
+return x_246;
 }
 }
 }
 else
 {
-lean_object* x_245; lean_object* x_246; 
+lean_object* x_247; lean_object* x_248; 
+lean_dec(x_213);
 lean_dec(x_211);
-lean_dec(x_209);
-x_245 = l_Lean_instToExprBool___lambda__1___closed__2;
-x_246 = l_Lean_Meta_mkEqRefl(x_245, x_2, x_3, x_4, x_5, x_210);
-if (lean_obj_tag(x_246) == 0)
+x_247 = l_Lean_instToExprBool___lambda__1___closed__2;
+x_248 = l_Lean_Meta_mkEqRefl(x_247, x_2, x_3, x_4, x_5, x_212);
+if (lean_obj_tag(x_248) == 0)
 {
-lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; 
-x_247 = lean_ctor_get(x_246, 0);
-lean_inc(x_247);
-x_248 = lean_ctor_get(x_246, 1);
-lean_inc(x_248);
-if (lean_is_exclusive(x_246)) {
- lean_ctor_release(x_246, 0);
- lean_ctor_release(x_246, 1);
- x_249 = x_246;
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; 
+x_249 = lean_ctor_get(x_248, 0);
+lean_inc(x_249);
+x_250 = lean_ctor_get(x_248, 1);
+lean_inc(x_250);
+if (lean_is_exclusive(x_248)) {
+ lean_ctor_release(x_248, 0);
+ lean_ctor_release(x_248, 1);
+ x_251 = x_248;
 } else {
- lean_dec_ref(x_246);
- x_249 = lean_box(0);
+ lean_dec_ref(x_248);
+ x_251 = lean_box(0);
 }
-x_250 = l_Lean_Expr_appArg_x21(x_203);
-lean_dec(x_203);
-x_251 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_252 = lean_array_push(x_251, x_1);
-x_253 = lean_array_push(x_252, x_250);
-x_254 = lean_array_push(x_253, x_247);
-x_255 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
-x_256 = l_Lean_mkAppN(x_255, x_254);
-lean_dec(x_254);
-x_257 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_257, 0, x_256);
-x_258 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
-x_259 = lean_alloc_ctor(0, 2, 0);
+x_252 = l_Lean_Expr_appArg_x21(x_205);
+lean_dec(x_205);
+x_253 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_254 = lean_array_push(x_253, x_1);
+x_255 = lean_array_push(x_254, x_252);
+x_256 = lean_array_push(x_255, x_249);
+x_257 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
+x_258 = l_Lean_mkAppN(x_257, x_256);
+lean_dec(x_256);
+x_259 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_259, 0, x_258);
-lean_ctor_set(x_259, 1, x_257);
-x_260 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_260, 0, x_259);
-if (lean_is_scalar(x_249)) {
- x_261 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_261 = x_249;
-}
+x_260 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
+x_261 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_261, 0, x_260);
-lean_ctor_set(x_261, 1, x_248);
-return x_261;
+lean_ctor_set(x_261, 1, x_259);
+x_262 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_262, 0, x_261);
+if (lean_is_scalar(x_251)) {
+ x_263 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_263 = x_251;
+}
+lean_ctor_set(x_263, 0, x_262);
+lean_ctor_set(x_263, 1, x_250);
+return x_263;
 }
 else
 {
-lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; 
-lean_dec(x_203);
+lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; 
+lean_dec(x_205);
 lean_dec(x_1);
-x_262 = lean_ctor_get(x_246, 1);
-lean_inc(x_262);
-if (lean_is_exclusive(x_246)) {
- lean_ctor_release(x_246, 0);
- lean_ctor_release(x_246, 1);
- x_263 = x_246;
+x_264 = lean_ctor_get(x_248, 1);
+lean_inc(x_264);
+if (lean_is_exclusive(x_248)) {
+ lean_ctor_release(x_248, 0);
+ lean_ctor_release(x_248, 1);
+ x_265 = x_248;
 } else {
- lean_dec_ref(x_246);
- x_263 = lean_box(0);
+ lean_dec_ref(x_248);
+ x_265 = lean_box(0);
 }
-x_264 = lean_box(0);
-if (lean_is_scalar(x_263)) {
- x_265 = lean_alloc_ctor(0, 2, 0);
+x_266 = lean_box(0);
+if (lean_is_scalar(x_265)) {
+ x_267 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_265 = x_263;
- lean_ctor_set_tag(x_265, 0);
+ x_267 = x_265;
+ lean_ctor_set_tag(x_267, 0);
 }
-lean_ctor_set(x_265, 0, x_264);
-lean_ctor_set(x_265, 1, x_262);
-return x_265;
+lean_ctor_set(x_267, 0, x_266);
+lean_ctor_set(x_267, 1, x_264);
+return x_267;
 }
 }
 }
 else
 {
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; 
-lean_dec(x_203);
+lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; 
+lean_dec(x_205);
 lean_dec(x_2);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_266 = lean_ctor_get(x_208, 1);
-lean_inc(x_266);
-if (lean_is_exclusive(x_208)) {
- lean_ctor_release(x_208, 0);
- lean_ctor_release(x_208, 1);
- x_267 = x_208;
+x_268 = lean_ctor_get(x_210, 1);
+lean_inc(x_268);
+if (lean_is_exclusive(x_210)) {
+ lean_ctor_release(x_210, 0);
+ lean_ctor_release(x_210, 1);
+ x_269 = x_210;
 } else {
- lean_dec_ref(x_208);
- x_267 = lean_box(0);
+ lean_dec_ref(x_210);
+ x_269 = lean_box(0);
 }
-x_268 = lean_box(0);
-if (lean_is_scalar(x_267)) {
- x_269 = lean_alloc_ctor(0, 2, 0);
+x_270 = lean_box(0);
+if (lean_is_scalar(x_269)) {
+ x_271 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_269 = x_267;
- lean_ctor_set_tag(x_269, 0);
+ x_271 = x_269;
+ lean_ctor_set_tag(x_271, 0);
 }
-lean_ctor_set(x_269, 0, x_268);
-lean_ctor_set(x_269, 1, x_266);
-return x_269;
+lean_ctor_set(x_271, 0, x_270);
+lean_ctor_set(x_271, 1, x_268);
+return x_271;
 }
 }
 else
 {
-lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; 
+lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; 
 lean_dec(x_2);
+lean_dec(x_192);
 lean_dec(x_191);
 lean_dec(x_190);
-lean_dec(x_189);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_270 = lean_ctor_get(x_202, 1);
-lean_inc(x_270);
-if (lean_is_exclusive(x_202)) {
- lean_ctor_release(x_202, 0);
- lean_ctor_release(x_202, 1);
- x_271 = x_202;
+x_272 = lean_ctor_get(x_204, 1);
+lean_inc(x_272);
+if (lean_is_exclusive(x_204)) {
+ lean_ctor_release(x_204, 0);
+ lean_ctor_release(x_204, 1);
+ x_273 = x_204;
 } else {
- lean_dec_ref(x_202);
- x_271 = lean_box(0);
+ lean_dec_ref(x_204);
+ x_273 = lean_box(0);
 }
-x_272 = lean_box(0);
-if (lean_is_scalar(x_271)) {
- x_273 = lean_alloc_ctor(0, 2, 0);
+x_274 = lean_box(0);
+if (lean_is_scalar(x_273)) {
+ x_275 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_273 = x_271;
- lean_ctor_set_tag(x_273, 0);
+ x_275 = x_273;
+ lean_ctor_set_tag(x_275, 0);
 }
-lean_ctor_set(x_273, 0, x_272);
-lean_ctor_set(x_273, 1, x_270);
-return x_273;
+lean_ctor_set(x_275, 0, x_274);
+lean_ctor_set(x_275, 1, x_272);
+return x_275;
 }
 }
 }
 else
 {
-lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; uint8_t x_279; uint8_t x_280; uint8_t x_281; uint8_t x_282; uint8_t x_283; uint8_t x_284; uint8_t x_285; lean_object* x_286; uint8_t x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; 
-x_274 = lean_ctor_get(x_2, 0);
-x_275 = lean_ctor_get(x_2, 1);
-x_276 = lean_ctor_get(x_2, 2);
-x_277 = lean_ctor_get(x_2, 3);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; uint8_t x_280; uint8_t x_281; uint8_t x_282; uint8_t x_283; uint8_t x_284; uint8_t x_285; uint8_t x_286; uint8_t x_287; uint8_t x_288; lean_object* x_289; uint8_t x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
+x_276 = lean_ctor_get(x_2, 0);
+x_277 = lean_ctor_get(x_2, 1);
+x_278 = lean_ctor_get(x_2, 2);
+x_279 = lean_ctor_get(x_2, 3);
+lean_inc(x_279);
+lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_inc(x_275);
-lean_inc(x_274);
 lean_dec(x_2);
-x_278 = lean_ctor_get_uint8(x_274, 0);
-x_279 = lean_ctor_get_uint8(x_274, 1);
-x_280 = lean_ctor_get_uint8(x_274, 2);
-x_281 = lean_ctor_get_uint8(x_274, 3);
-x_282 = lean_ctor_get_uint8(x_274, 4);
-x_283 = lean_ctor_get_uint8(x_274, 6);
-x_284 = lean_ctor_get_uint8(x_274, 7);
-x_285 = lean_ctor_get_uint8(x_274, 8);
-if (lean_is_exclusive(x_274)) {
- x_286 = x_274;
+x_280 = lean_ctor_get_uint8(x_276, 0);
+x_281 = lean_ctor_get_uint8(x_276, 1);
+x_282 = lean_ctor_get_uint8(x_276, 2);
+x_283 = lean_ctor_get_uint8(x_276, 3);
+x_284 = lean_ctor_get_uint8(x_276, 4);
+x_285 = lean_ctor_get_uint8(x_276, 6);
+x_286 = lean_ctor_get_uint8(x_276, 7);
+x_287 = lean_ctor_get_uint8(x_276, 8);
+x_288 = lean_ctor_get_uint8(x_276, 9);
+if (lean_is_exclusive(x_276)) {
+ x_289 = x_276;
 } else {
- lean_dec_ref(x_274);
- x_286 = lean_box(0);
+ lean_dec_ref(x_276);
+ x_289 = lean_box(0);
 }
-x_287 = 3;
-if (lean_is_scalar(x_286)) {
- x_288 = lean_alloc_ctor(0, 0, 9);
+x_290 = 3;
+if (lean_is_scalar(x_289)) {
+ x_291 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_288 = x_286;
+ x_291 = x_289;
 }
-lean_ctor_set_uint8(x_288, 0, x_278);
-lean_ctor_set_uint8(x_288, 1, x_279);
-lean_ctor_set_uint8(x_288, 2, x_280);
-lean_ctor_set_uint8(x_288, 3, x_281);
-lean_ctor_set_uint8(x_288, 4, x_282);
-lean_ctor_set_uint8(x_288, 5, x_287);
-lean_ctor_set_uint8(x_288, 6, x_283);
-lean_ctor_set_uint8(x_288, 7, x_284);
-lean_ctor_set_uint8(x_288, 8, x_285);
+lean_ctor_set_uint8(x_291, 0, x_280);
+lean_ctor_set_uint8(x_291, 1, x_281);
+lean_ctor_set_uint8(x_291, 2, x_282);
+lean_ctor_set_uint8(x_291, 3, x_283);
+lean_ctor_set_uint8(x_291, 4, x_284);
+lean_ctor_set_uint8(x_291, 5, x_290);
+lean_ctor_set_uint8(x_291, 6, x_285);
+lean_ctor_set_uint8(x_291, 7, x_286);
+lean_ctor_set_uint8(x_291, 8, x_287);
+lean_ctor_set_uint8(x_291, 9, x_288);
+lean_inc(x_279);
+lean_inc(x_278);
 lean_inc(x_277);
-lean_inc(x_276);
-lean_inc(x_275);
-x_289 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_289, 0, x_288);
-lean_ctor_set(x_289, 1, x_275);
-lean_ctor_set(x_289, 2, x_276);
-lean_ctor_set(x_289, 3, x_277);
+x_292 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_292, 0, x_291);
+lean_ctor_set(x_292, 1, x_277);
+lean_ctor_set(x_292, 2, x_278);
+lean_ctor_set(x_292, 3, x_279);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_289);
-lean_inc(x_1);
-x_290 = l_Lean_Meta_mkDecide(x_1, x_289, x_3, x_4, x_5, x_6);
-if (lean_obj_tag(x_290) == 0)
-{
-lean_object* x_291; lean_object* x_292; uint8_t x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; 
-x_291 = lean_ctor_get(x_290, 0);
-lean_inc(x_291);
-x_292 = lean_ctor_get(x_290, 1);
 lean_inc(x_292);
-lean_dec(x_290);
-x_293 = 1;
-x_294 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_294, 0, x_278);
-lean_ctor_set_uint8(x_294, 1, x_279);
-lean_ctor_set_uint8(x_294, 2, x_280);
-lean_ctor_set_uint8(x_294, 3, x_281);
-lean_ctor_set_uint8(x_294, 4, x_282);
-lean_ctor_set_uint8(x_294, 5, x_293);
-lean_ctor_set_uint8(x_294, 6, x_283);
-lean_ctor_set_uint8(x_294, 7, x_284);
-lean_ctor_set_uint8(x_294, 8, x_285);
-x_295 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_295, 0, x_294);
-lean_ctor_set(x_295, 1, x_275);
-lean_ctor_set(x_295, 2, x_276);
-lean_ctor_set(x_295, 3, x_277);
+lean_inc(x_1);
+x_293 = l_Lean_Meta_mkDecide(x_1, x_292, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_293) == 0)
+{
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; 
+x_294 = lean_ctor_get(x_293, 0);
+lean_inc(x_294);
+x_295 = lean_ctor_get(x_293, 1);
+lean_inc(x_295);
+lean_dec(x_293);
+x_296 = 1;
+x_297 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_297, 0, x_280);
+lean_ctor_set_uint8(x_297, 1, x_281);
+lean_ctor_set_uint8(x_297, 2, x_282);
+lean_ctor_set_uint8(x_297, 3, x_283);
+lean_ctor_set_uint8(x_297, 4, x_284);
+lean_ctor_set_uint8(x_297, 5, x_296);
+lean_ctor_set_uint8(x_297, 6, x_285);
+lean_ctor_set_uint8(x_297, 7, x_286);
+lean_ctor_set_uint8(x_297, 8, x_287);
+lean_ctor_set_uint8(x_297, 9, x_288);
+x_298 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_298, 0, x_297);
+lean_ctor_set(x_298, 1, x_277);
+lean_ctor_set(x_298, 2, x_278);
+lean_ctor_set(x_298, 3, x_279);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_291);
-x_296 = l_Lean_Meta_whnf(x_291, x_295, x_3, x_4, x_5, x_292);
-if (lean_obj_tag(x_296) == 0)
+lean_inc(x_294);
+x_299 = l_Lean_Meta_whnf(x_294, x_298, x_3, x_4, x_5, x_295);
+if (lean_obj_tag(x_299) == 0)
 {
-lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; uint8_t x_301; 
-x_297 = lean_ctor_get(x_296, 0);
-lean_inc(x_297);
-x_298 = lean_ctor_get(x_296, 1);
-lean_inc(x_298);
-if (lean_is_exclusive(x_296)) {
- lean_ctor_release(x_296, 0);
- lean_ctor_release(x_296, 1);
- x_299 = x_296;
+lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
+x_300 = lean_ctor_get(x_299, 0);
+lean_inc(x_300);
+x_301 = lean_ctor_get(x_299, 1);
+lean_inc(x_301);
+if (lean_is_exclusive(x_299)) {
+ lean_ctor_release(x_299, 0);
+ lean_ctor_release(x_299, 1);
+ x_302 = x_299;
 } else {
- lean_dec_ref(x_296);
- x_299 = lean_box(0);
+ lean_dec_ref(x_299);
+ x_302 = lean_box(0);
 }
-x_300 = l_Lean_instQuoteBool___closed__5;
-x_301 = l_Lean_Expr_isConstOf(x_297, x_300);
-if (x_301 == 0)
+x_303 = l_Lean_instQuoteBool___closed__5;
+x_304 = l_Lean_Expr_isConstOf(x_300, x_303);
+if (x_304 == 0)
 {
-lean_object* x_302; uint8_t x_303; 
-x_302 = l_Lean_instQuoteBool___closed__3;
-x_303 = l_Lean_Expr_isConstOf(x_297, x_302);
-lean_dec(x_297);
-if (x_303 == 0)
+lean_object* x_305; uint8_t x_306; 
+x_305 = l_Lean_instQuoteBool___closed__3;
+x_306 = l_Lean_Expr_isConstOf(x_300, x_305);
+lean_dec(x_300);
+if (x_306 == 0)
 {
-lean_object* x_304; lean_object* x_305; 
-lean_dec(x_291);
-lean_dec(x_289);
+lean_object* x_307; lean_object* x_308; 
+lean_dec(x_294);
+lean_dec(x_292);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_304 = lean_box(0);
-if (lean_is_scalar(x_299)) {
- x_305 = lean_alloc_ctor(0, 2, 0);
+x_307 = lean_box(0);
+if (lean_is_scalar(x_302)) {
+ x_308 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_305 = x_299;
+ x_308 = x_302;
 }
-lean_ctor_set(x_305, 0, x_304);
-lean_ctor_set(x_305, 1, x_298);
-return x_305;
+lean_ctor_set(x_308, 0, x_307);
+lean_ctor_set(x_308, 1, x_301);
+return x_308;
 }
 else
 {
-lean_object* x_306; 
-lean_dec(x_299);
+lean_object* x_309; 
+lean_dec(x_302);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_289);
-lean_inc(x_291);
-x_306 = l_Lean_Meta_mkEqRefl(x_291, x_289, x_3, x_4, x_5, x_298);
-if (lean_obj_tag(x_306) == 0)
-{
-lean_object* x_307; lean_object* x_308; lean_object* x_309; 
-x_307 = lean_ctor_get(x_306, 1);
-lean_inc(x_307);
-lean_dec(x_306);
-x_308 = l_Lean_instToExprBool___lambda__1___closed__1;
-x_309 = l_Lean_Meta_mkEqRefl(x_308, x_289, x_3, x_4, x_5, x_307);
+lean_inc(x_292);
+lean_inc(x_294);
+x_309 = l_Lean_Meta_mkEqRefl(x_294, x_292, x_3, x_4, x_5, x_301);
 if (lean_obj_tag(x_309) == 0)
 {
-lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; 
-x_310 = lean_ctor_get(x_309, 0);
+lean_object* x_310; lean_object* x_311; lean_object* x_312; 
+x_310 = lean_ctor_get(x_309, 1);
 lean_inc(x_310);
-x_311 = lean_ctor_get(x_309, 1);
-lean_inc(x_311);
-if (lean_is_exclusive(x_309)) {
- lean_ctor_release(x_309, 0);
- lean_ctor_release(x_309, 1);
- x_312 = x_309;
+lean_dec(x_309);
+x_311 = l_Lean_instToExprBool___lambda__1___closed__1;
+x_312 = l_Lean_Meta_mkEqRefl(x_311, x_292, x_3, x_4, x_5, x_310);
+if (lean_obj_tag(x_312) == 0)
+{
+lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; 
+x_313 = lean_ctor_get(x_312, 0);
+lean_inc(x_313);
+x_314 = lean_ctor_get(x_312, 1);
+lean_inc(x_314);
+if (lean_is_exclusive(x_312)) {
+ lean_ctor_release(x_312, 0);
+ lean_ctor_release(x_312, 1);
+ x_315 = x_312;
 } else {
- lean_dec_ref(x_309);
- x_312 = lean_box(0);
+ lean_dec_ref(x_312);
+ x_315 = lean_box(0);
 }
-x_313 = l_Lean_Expr_appArg_x21(x_291);
-lean_dec(x_291);
-x_314 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_315 = lean_array_push(x_314, x_1);
-x_316 = lean_array_push(x_315, x_313);
-x_317 = lean_array_push(x_316, x_310);
-x_318 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
-x_319 = l_Lean_mkAppN(x_318, x_317);
-lean_dec(x_317);
-x_320 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_320, 0, x_319);
-x_321 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
-x_322 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_322, 0, x_321);
-lean_ctor_set(x_322, 1, x_320);
+x_316 = l_Lean_Expr_appArg_x21(x_294);
+lean_dec(x_294);
+x_317 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_318 = lean_array_push(x_317, x_1);
+x_319 = lean_array_push(x_318, x_316);
+x_320 = lean_array_push(x_319, x_313);
+x_321 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__3;
+x_322 = l_Lean_mkAppN(x_321, x_320);
+lean_dec(x_320);
 x_323 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_323, 0, x_322);
-if (lean_is_scalar(x_312)) {
- x_324 = lean_alloc_ctor(0, 2, 0);
+x_324 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__2;
+x_325 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_325, 0, x_324);
+lean_ctor_set(x_325, 1, x_323);
+x_326 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_326, 0, x_325);
+if (lean_is_scalar(x_315)) {
+ x_327 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_324 = x_312;
+ x_327 = x_315;
 }
-lean_ctor_set(x_324, 0, x_323);
-lean_ctor_set(x_324, 1, x_311);
-return x_324;
+lean_ctor_set(x_327, 0, x_326);
+lean_ctor_set(x_327, 1, x_314);
+return x_327;
 }
 else
 {
-lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; 
-lean_dec(x_291);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; 
+lean_dec(x_294);
 lean_dec(x_1);
-x_325 = lean_ctor_get(x_309, 1);
-lean_inc(x_325);
+x_328 = lean_ctor_get(x_312, 1);
+lean_inc(x_328);
+if (lean_is_exclusive(x_312)) {
+ lean_ctor_release(x_312, 0);
+ lean_ctor_release(x_312, 1);
+ x_329 = x_312;
+} else {
+ lean_dec_ref(x_312);
+ x_329 = lean_box(0);
+}
+x_330 = lean_box(0);
+if (lean_is_scalar(x_329)) {
+ x_331 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_331 = x_329;
+ lean_ctor_set_tag(x_331, 0);
+}
+lean_ctor_set(x_331, 0, x_330);
+lean_ctor_set(x_331, 1, x_328);
+return x_331;
+}
+}
+else
+{
+lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; 
+lean_dec(x_294);
+lean_dec(x_292);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_332 = lean_ctor_get(x_309, 1);
+lean_inc(x_332);
 if (lean_is_exclusive(x_309)) {
  lean_ctor_release(x_309, 0);
  lean_ctor_release(x_309, 1);
- x_326 = x_309;
+ x_333 = x_309;
 } else {
  lean_dec_ref(x_309);
- x_326 = lean_box(0);
+ x_333 = lean_box(0);
 }
-x_327 = lean_box(0);
-if (lean_is_scalar(x_326)) {
- x_328 = lean_alloc_ctor(0, 2, 0);
+x_334 = lean_box(0);
+if (lean_is_scalar(x_333)) {
+ x_335 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_328 = x_326;
- lean_ctor_set_tag(x_328, 0);
+ x_335 = x_333;
+ lean_ctor_set_tag(x_335, 0);
 }
-lean_ctor_set(x_328, 0, x_327);
-lean_ctor_set(x_328, 1, x_325);
-return x_328;
-}
-}
-else
-{
-lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; 
-lean_dec(x_291);
-lean_dec(x_289);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_329 = lean_ctor_get(x_306, 1);
-lean_inc(x_329);
-if (lean_is_exclusive(x_306)) {
- lean_ctor_release(x_306, 0);
- lean_ctor_release(x_306, 1);
- x_330 = x_306;
-} else {
- lean_dec_ref(x_306);
- x_330 = lean_box(0);
-}
-x_331 = lean_box(0);
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_332 = x_330;
- lean_ctor_set_tag(x_332, 0);
-}
-lean_ctor_set(x_332, 0, x_331);
-lean_ctor_set(x_332, 1, x_329);
-return x_332;
+lean_ctor_set(x_335, 0, x_334);
+lean_ctor_set(x_335, 1, x_332);
+return x_335;
 }
 }
 }
 else
 {
-lean_object* x_333; lean_object* x_334; 
-lean_dec(x_299);
-lean_dec(x_297);
-x_333 = l_Lean_instToExprBool___lambda__1___closed__2;
-x_334 = l_Lean_Meta_mkEqRefl(x_333, x_289, x_3, x_4, x_5, x_298);
-if (lean_obj_tag(x_334) == 0)
+lean_object* x_336; lean_object* x_337; 
+lean_dec(x_302);
+lean_dec(x_300);
+x_336 = l_Lean_instToExprBool___lambda__1___closed__2;
+x_337 = l_Lean_Meta_mkEqRefl(x_336, x_292, x_3, x_4, x_5, x_301);
+if (lean_obj_tag(x_337) == 0)
 {
-lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; 
-x_335 = lean_ctor_get(x_334, 0);
-lean_inc(x_335);
-x_336 = lean_ctor_get(x_334, 1);
-lean_inc(x_336);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- x_337 = x_334;
+lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; 
+x_338 = lean_ctor_get(x_337, 0);
+lean_inc(x_338);
+x_339 = lean_ctor_get(x_337, 1);
+lean_inc(x_339);
+if (lean_is_exclusive(x_337)) {
+ lean_ctor_release(x_337, 0);
+ lean_ctor_release(x_337, 1);
+ x_340 = x_337;
 } else {
- lean_dec_ref(x_334);
- x_337 = lean_box(0);
+ lean_dec_ref(x_337);
+ x_340 = lean_box(0);
 }
-x_338 = l_Lean_Expr_appArg_x21(x_291);
-lean_dec(x_291);
-x_339 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
-x_340 = lean_array_push(x_339, x_1);
-x_341 = lean_array_push(x_340, x_338);
-x_342 = lean_array_push(x_341, x_335);
-x_343 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
-x_344 = l_Lean_mkAppN(x_343, x_342);
-lean_dec(x_342);
-x_345 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_345, 0, x_344);
-x_346 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
-x_347 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_347, 0, x_346);
-lean_ctor_set(x_347, 1, x_345);
+x_341 = l_Lean_Expr_appArg_x21(x_294);
+lean_dec(x_294);
+x_342 = l_unexpand____x40_Init_Notation___hyg_1981____closed__1;
+x_343 = lean_array_push(x_342, x_1);
+x_344 = lean_array_push(x_343, x_341);
+x_345 = lean_array_push(x_344, x_338);
+x_346 = l_Lean_Meta_Simp_rewriteUsingDecide_x3f___closed__6;
+x_347 = l_Lean_mkAppN(x_346, x_345);
+lean_dec(x_345);
 x_348 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_348, 0, x_347);
-if (lean_is_scalar(x_337)) {
- x_349 = lean_alloc_ctor(0, 2, 0);
+x_349 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess___closed__1;
+x_350 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_350, 0, x_349);
+lean_ctor_set(x_350, 1, x_348);
+x_351 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_351, 0, x_350);
+if (lean_is_scalar(x_340)) {
+ x_352 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_349 = x_337;
+ x_352 = x_340;
 }
-lean_ctor_set(x_349, 0, x_348);
-lean_ctor_set(x_349, 1, x_336);
-return x_349;
+lean_ctor_set(x_352, 0, x_351);
+lean_ctor_set(x_352, 1, x_339);
+return x_352;
 }
 else
 {
-lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; 
-lean_dec(x_291);
+lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; 
+lean_dec(x_294);
 lean_dec(x_1);
-x_350 = lean_ctor_get(x_334, 1);
-lean_inc(x_350);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- x_351 = x_334;
+x_353 = lean_ctor_get(x_337, 1);
+lean_inc(x_353);
+if (lean_is_exclusive(x_337)) {
+ lean_ctor_release(x_337, 0);
+ lean_ctor_release(x_337, 1);
+ x_354 = x_337;
 } else {
- lean_dec_ref(x_334);
- x_351 = lean_box(0);
+ lean_dec_ref(x_337);
+ x_354 = lean_box(0);
 }
-x_352 = lean_box(0);
-if (lean_is_scalar(x_351)) {
- x_353 = lean_alloc_ctor(0, 2, 0);
+x_355 = lean_box(0);
+if (lean_is_scalar(x_354)) {
+ x_356 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_353 = x_351;
- lean_ctor_set_tag(x_353, 0);
+ x_356 = x_354;
+ lean_ctor_set_tag(x_356, 0);
 }
-lean_ctor_set(x_353, 0, x_352);
-lean_ctor_set(x_353, 1, x_350);
-return x_353;
+lean_ctor_set(x_356, 0, x_355);
+lean_ctor_set(x_356, 1, x_353);
+return x_356;
 }
 }
 }
 else
 {
-lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; 
-lean_dec(x_291);
-lean_dec(x_289);
+lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; 
+lean_dec(x_294);
+lean_dec(x_292);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_354 = lean_ctor_get(x_296, 1);
-lean_inc(x_354);
-if (lean_is_exclusive(x_296)) {
- lean_ctor_release(x_296, 0);
- lean_ctor_release(x_296, 1);
- x_355 = x_296;
+x_357 = lean_ctor_get(x_299, 1);
+lean_inc(x_357);
+if (lean_is_exclusive(x_299)) {
+ lean_ctor_release(x_299, 0);
+ lean_ctor_release(x_299, 1);
+ x_358 = x_299;
 } else {
- lean_dec_ref(x_296);
- x_355 = lean_box(0);
+ lean_dec_ref(x_299);
+ x_358 = lean_box(0);
 }
-x_356 = lean_box(0);
-if (lean_is_scalar(x_355)) {
- x_357 = lean_alloc_ctor(0, 2, 0);
+x_359 = lean_box(0);
+if (lean_is_scalar(x_358)) {
+ x_360 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_357 = x_355;
- lean_ctor_set_tag(x_357, 0);
+ x_360 = x_358;
+ lean_ctor_set_tag(x_360, 0);
 }
-lean_ctor_set(x_357, 0, x_356);
-lean_ctor_set(x_357, 1, x_354);
-return x_357;
+lean_ctor_set(x_360, 0, x_359);
+lean_ctor_set(x_360, 1, x_357);
+return x_360;
 }
 }
 else
 {
-lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; 
-lean_dec(x_289);
+lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; 
+lean_dec(x_292);
+lean_dec(x_279);
+lean_dec(x_278);
 lean_dec(x_277);
-lean_dec(x_276);
-lean_dec(x_275);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_358 = lean_ctor_get(x_290, 1);
-lean_inc(x_358);
-if (lean_is_exclusive(x_290)) {
- lean_ctor_release(x_290, 0);
- lean_ctor_release(x_290, 1);
- x_359 = x_290;
+x_361 = lean_ctor_get(x_293, 1);
+lean_inc(x_361);
+if (lean_is_exclusive(x_293)) {
+ lean_ctor_release(x_293, 0);
+ lean_ctor_release(x_293, 1);
+ x_362 = x_293;
 } else {
- lean_dec_ref(x_290);
- x_359 = lean_box(0);
+ lean_dec_ref(x_293);
+ x_362 = lean_box(0);
 }
-x_360 = lean_box(0);
-if (lean_is_scalar(x_359)) {
- x_361 = lean_alloc_ctor(0, 2, 0);
+x_363 = lean_box(0);
+if (lean_is_scalar(x_362)) {
+ x_364 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_361 = x_359;
- lean_ctor_set_tag(x_361, 0);
+ x_364 = x_362;
+ lean_ctor_set_tag(x_364, 0);
 }
-lean_ctor_set(x_361, 0, x_360);
-lean_ctor_set(x_361, 1, x_358);
-return x_361;
+lean_ctor_set(x_364, 0, x_363);
+lean_ctor_set(x_364, 1, x_361);
+return x_364;
 }
 }
 }
 else
 {
-lean_object* x_362; lean_object* x_363; 
+lean_object* x_365; lean_object* x_366; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_362 = lean_box(0);
-x_363 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_363, 0, x_362);
-lean_ctor_set(x_363, 1, x_6);
-return x_363;
+x_365 = lean_box(0);
+x_366 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_366, 0, x_365);
+lean_ctor_set(x_366, 1, x_6);
+return x_366;
 }
 }
 else
 {
-lean_object* x_364; lean_object* x_365; 
+lean_object* x_367; lean_object* x_368; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_364 = lean_box(0);
-x_365 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_365, 0, x_364);
-lean_ctor_set(x_365, 1, x_6);
-return x_365;
+x_367 = lean_box(0);
+x_368 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_368, 0, x_367);
+lean_ctor_set(x_368, 1, x_6);
+return x_368;
 }
 }
 else
 {
-lean_object* x_366; lean_object* x_367; 
+lean_object* x_369; lean_object* x_370; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_366 = lean_box(0);
-x_367 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_367, 0, x_366);
-lean_ctor_set(x_367, 1, x_6);
-return x_367;
+x_369 = lean_box(0);
+x_370 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_370, 0, x_369);
+lean_ctor_set(x_370, 1, x_6);
+return x_370;
 }
 }
 else
 {
-lean_object* x_368; lean_object* x_369; 
+lean_object* x_371; lean_object* x_372; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_368 = lean_box(0);
-x_369 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_369, 0, x_368);
-lean_ctor_set(x_369, 1, x_6);
-return x_369;
+x_371 = lean_box(0);
+x_372 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_372, 0, x_371);
+lean_ctor_set(x_372, 1, x_6);
+return x_372;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Simp/SimpLemmas.c b/stage0/stdlib/Lean/Meta/Tactic/Simp/SimpLemmas.c
index dd83f30bde..f389c09b52 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Simp/SimpLemmas.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Simp/SimpLemmas.c
@@ -198,7 +198,6 @@ extern lean_object* l_Lean_instInhabitedExpr;
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Simp_SimpLemmas___hyg_2305____lambda__1___closed__2;
 lean_object* l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmaCore_match__3(lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_shouldPreprocess___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__4;
 lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkEqTrue(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isConst(lean_object*);
@@ -222,6 +221,7 @@ lean_object* l_Lean_ConstantInfo_type(lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Simp_SimpLemmas___hyg_2305____closed__4;
 lean_object* l_Std_PersistentHashMap_insert___at_Lean_Meta_addSimpLemmaEntry___spec__5(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getSimpLemmas___rarg(lean_object*, lean_object*);
+extern lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 size_t l_USize_land(size_t, size_t);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Simp_SimpLemmas___hyg_2305____lambda__1___closed__1;
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Simp_SimpLemmas___hyg_2305____closed__1;
@@ -6171,7 +6171,7 @@ x_16 = l_Lean_Expr_isAppOfArity(x_10, x_14, x_15);
 if (x_16 == 0)
 {
 lean_object* x_17; lean_object* x_18; uint8_t x_19; 
-x_17 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_17 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_18 = lean_unsigned_to_nat(3u);
 x_19 = l_Lean_Expr_isAppOfArity(x_10, x_17, x_18);
 if (x_19 == 0)
@@ -6830,7 +6830,7 @@ x_167 = l_Lean_Expr_isAppOfArity(x_161, x_165, x_166);
 if (x_167 == 0)
 {
 lean_object* x_168; lean_object* x_169; uint8_t x_170; 
-x_168 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_168 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_169 = lean_unsigned_to_nat(3u);
 x_170 = l_Lean_Expr_isAppOfArity(x_161, x_168, x_169);
 if (x_170 == 0)
@@ -7808,7 +7808,7 @@ return x_22;
 }
 else
 {
-uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; lean_object* x_32; uint8_t x_33; uint8_t x_34; lean_object* x_35; 
+uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; uint8_t x_32; lean_object* x_33; uint8_t x_34; uint8_t x_35; lean_object* x_36; 
 x_23 = lean_ctor_get_uint8(x_9, 0);
 x_24 = lean_ctor_get_uint8(x_9, 1);
 x_25 = lean_ctor_get_uint8(x_9, 2);
@@ -7817,168 +7817,172 @@ x_27 = lean_ctor_get_uint8(x_9, 4);
 x_28 = lean_ctor_get_uint8(x_9, 6);
 x_29 = lean_ctor_get_uint8(x_9, 7);
 x_30 = lean_ctor_get_uint8(x_9, 8);
+x_31 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_31 = 2;
-x_32 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_32, 0, x_23);
-lean_ctor_set_uint8(x_32, 1, x_24);
-lean_ctor_set_uint8(x_32, 2, x_25);
-lean_ctor_set_uint8(x_32, 3, x_26);
-lean_ctor_set_uint8(x_32, 4, x_27);
-lean_ctor_set_uint8(x_32, 5, x_31);
-lean_ctor_set_uint8(x_32, 6, x_28);
-lean_ctor_set_uint8(x_32, 7, x_29);
-lean_ctor_set_uint8(x_32, 8, x_30);
-lean_ctor_set(x_3, 0, x_32);
-x_33 = 1;
-x_34 = 0;
-x_35 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_1, x_33, x_2, x_34, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_35) == 0)
+x_32 = 2;
+x_33 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_33, 0, x_23);
+lean_ctor_set_uint8(x_33, 1, x_24);
+lean_ctor_set_uint8(x_33, 2, x_25);
+lean_ctor_set_uint8(x_33, 3, x_26);
+lean_ctor_set_uint8(x_33, 4, x_27);
+lean_ctor_set_uint8(x_33, 5, x_32);
+lean_ctor_set_uint8(x_33, 6, x_28);
+lean_ctor_set_uint8(x_33, 7, x_29);
+lean_ctor_set_uint8(x_33, 8, x_30);
+lean_ctor_set_uint8(x_33, 9, x_31);
+lean_ctor_set(x_3, 0, x_33);
+x_34 = 1;
+x_35 = 0;
+x_36 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_1, x_34, x_2, x_35, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_36) == 0)
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_36 = lean_ctor_get(x_35, 0);
-lean_inc(x_36);
-x_37 = lean_ctor_get(x_35, 1);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_37 = lean_ctor_get(x_36, 0);
 lean_inc(x_37);
-if (lean_is_exclusive(x_35)) {
- lean_ctor_release(x_35, 0);
- lean_ctor_release(x_35, 1);
- x_38 = x_35;
+x_38 = lean_ctor_get(x_36, 1);
+lean_inc(x_38);
+if (lean_is_exclusive(x_36)) {
+ lean_ctor_release(x_36, 0);
+ lean_ctor_release(x_36, 1);
+ x_39 = x_36;
 } else {
- lean_dec_ref(x_35);
- x_38 = lean_box(0);
+ lean_dec_ref(x_36);
+ x_39 = lean_box(0);
 }
-if (lean_is_scalar(x_38)) {
- x_39 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_39)) {
+ x_40 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_39 = x_38;
+ x_40 = x_39;
 }
-lean_ctor_set(x_39, 0, x_36);
-lean_ctor_set(x_39, 1, x_37);
-return x_39;
+lean_ctor_set(x_40, 0, x_37);
+lean_ctor_set(x_40, 1, x_38);
+return x_40;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_40 = lean_ctor_get(x_35, 0);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_35, 1);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_41 = lean_ctor_get(x_36, 0);
 lean_inc(x_41);
-if (lean_is_exclusive(x_35)) {
- lean_ctor_release(x_35, 0);
- lean_ctor_release(x_35, 1);
- x_42 = x_35;
+x_42 = lean_ctor_get(x_36, 1);
+lean_inc(x_42);
+if (lean_is_exclusive(x_36)) {
+ lean_ctor_release(x_36, 0);
+ lean_ctor_release(x_36, 1);
+ x_43 = x_36;
 } else {
- lean_dec_ref(x_35);
- x_42 = lean_box(0);
+ lean_dec_ref(x_36);
+ x_43 = lean_box(0);
 }
-if (lean_is_scalar(x_42)) {
- x_43 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_43)) {
+ x_44 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_43 = x_42;
+ x_44 = x_43;
 }
-lean_ctor_set(x_43, 0, x_40);
-lean_ctor_set(x_43, 1, x_41);
-return x_43;
+lean_ctor_set(x_44, 0, x_41);
+lean_ctor_set(x_44, 1, x_42);
+return x_44;
 }
 }
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; uint8_t x_61; lean_object* x_62; 
-x_44 = lean_ctor_get(x_3, 0);
-x_45 = lean_ctor_get(x_3, 1);
-x_46 = lean_ctor_get(x_3, 2);
-x_47 = lean_ctor_get(x_3, 3);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; uint8_t x_54; uint8_t x_55; uint8_t x_56; uint8_t x_57; lean_object* x_58; uint8_t x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; uint8_t x_63; lean_object* x_64; 
+x_45 = lean_ctor_get(x_3, 0);
+x_46 = lean_ctor_get(x_3, 1);
+x_47 = lean_ctor_get(x_3, 2);
+x_48 = lean_ctor_get(x_3, 3);
+lean_inc(x_48);
 lean_inc(x_47);
 lean_inc(x_46);
 lean_inc(x_45);
-lean_inc(x_44);
 lean_dec(x_3);
-x_48 = lean_ctor_get_uint8(x_44, 0);
-x_49 = lean_ctor_get_uint8(x_44, 1);
-x_50 = lean_ctor_get_uint8(x_44, 2);
-x_51 = lean_ctor_get_uint8(x_44, 3);
-x_52 = lean_ctor_get_uint8(x_44, 4);
-x_53 = lean_ctor_get_uint8(x_44, 6);
-x_54 = lean_ctor_get_uint8(x_44, 7);
-x_55 = lean_ctor_get_uint8(x_44, 8);
-if (lean_is_exclusive(x_44)) {
- x_56 = x_44;
+x_49 = lean_ctor_get_uint8(x_45, 0);
+x_50 = lean_ctor_get_uint8(x_45, 1);
+x_51 = lean_ctor_get_uint8(x_45, 2);
+x_52 = lean_ctor_get_uint8(x_45, 3);
+x_53 = lean_ctor_get_uint8(x_45, 4);
+x_54 = lean_ctor_get_uint8(x_45, 6);
+x_55 = lean_ctor_get_uint8(x_45, 7);
+x_56 = lean_ctor_get_uint8(x_45, 8);
+x_57 = lean_ctor_get_uint8(x_45, 9);
+if (lean_is_exclusive(x_45)) {
+ x_58 = x_45;
 } else {
- lean_dec_ref(x_44);
- x_56 = lean_box(0);
+ lean_dec_ref(x_45);
+ x_58 = lean_box(0);
 }
-x_57 = 2;
-if (lean_is_scalar(x_56)) {
- x_58 = lean_alloc_ctor(0, 0, 9);
+x_59 = 2;
+if (lean_is_scalar(x_58)) {
+ x_60 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_58 = x_56;
+ x_60 = x_58;
 }
-lean_ctor_set_uint8(x_58, 0, x_48);
-lean_ctor_set_uint8(x_58, 1, x_49);
-lean_ctor_set_uint8(x_58, 2, x_50);
-lean_ctor_set_uint8(x_58, 3, x_51);
-lean_ctor_set_uint8(x_58, 4, x_52);
-lean_ctor_set_uint8(x_58, 5, x_57);
-lean_ctor_set_uint8(x_58, 6, x_53);
-lean_ctor_set_uint8(x_58, 7, x_54);
-lean_ctor_set_uint8(x_58, 8, x_55);
-x_59 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_59, 0, x_58);
-lean_ctor_set(x_59, 1, x_45);
-lean_ctor_set(x_59, 2, x_46);
-lean_ctor_set(x_59, 3, x_47);
-x_60 = 1;
-x_61 = 0;
-x_62 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_1, x_60, x_2, x_61, x_59, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_62) == 0)
+lean_ctor_set_uint8(x_60, 0, x_49);
+lean_ctor_set_uint8(x_60, 1, x_50);
+lean_ctor_set_uint8(x_60, 2, x_51);
+lean_ctor_set_uint8(x_60, 3, x_52);
+lean_ctor_set_uint8(x_60, 4, x_53);
+lean_ctor_set_uint8(x_60, 5, x_59);
+lean_ctor_set_uint8(x_60, 6, x_54);
+lean_ctor_set_uint8(x_60, 7, x_55);
+lean_ctor_set_uint8(x_60, 8, x_56);
+lean_ctor_set_uint8(x_60, 9, x_57);
+x_61 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_61, 0, x_60);
+lean_ctor_set(x_61, 1, x_46);
+lean_ctor_set(x_61, 2, x_47);
+lean_ctor_set(x_61, 3, x_48);
+x_62 = 1;
+x_63 = 0;
+x_64 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(x_1, x_62, x_2, x_63, x_61, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_64) == 0)
 {
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_ctor_get(x_62, 1);
-lean_inc(x_64);
-if (lean_is_exclusive(x_62)) {
- lean_ctor_release(x_62, 0);
- lean_ctor_release(x_62, 1);
- x_65 = x_62;
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+x_65 = lean_ctor_get(x_64, 0);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_64, 1);
+lean_inc(x_66);
+if (lean_is_exclusive(x_64)) {
+ lean_ctor_release(x_64, 0);
+ lean_ctor_release(x_64, 1);
+ x_67 = x_64;
 } else {
- lean_dec_ref(x_62);
- x_65 = lean_box(0);
+ lean_dec_ref(x_64);
+ x_67 = lean_box(0);
 }
-if (lean_is_scalar(x_65)) {
- x_66 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_67)) {
+ x_68 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_66 = x_65;
+ x_68 = x_67;
 }
-lean_ctor_set(x_66, 0, x_63);
-lean_ctor_set(x_66, 1, x_64);
-return x_66;
+lean_ctor_set(x_68, 0, x_65);
+lean_ctor_set(x_68, 1, x_66);
+return x_68;
 }
 else
 {
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-x_67 = lean_ctor_get(x_62, 0);
-lean_inc(x_67);
-x_68 = lean_ctor_get(x_62, 1);
-lean_inc(x_68);
-if (lean_is_exclusive(x_62)) {
- lean_ctor_release(x_62, 0);
- lean_ctor_release(x_62, 1);
- x_69 = x_62;
+lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_69 = lean_ctor_get(x_64, 0);
+lean_inc(x_69);
+x_70 = lean_ctor_get(x_64, 1);
+lean_inc(x_70);
+if (lean_is_exclusive(x_64)) {
+ lean_ctor_release(x_64, 0);
+ lean_ctor_release(x_64, 1);
+ x_71 = x_64;
 } else {
- lean_dec_ref(x_62);
- x_69 = lean_box(0);
+ lean_dec_ref(x_64);
+ x_71 = lean_box(0);
 }
-if (lean_is_scalar(x_69)) {
- x_70 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_71)) {
+ x_72 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_70 = x_69;
+ x_72 = x_71;
 }
-lean_ctor_set(x_70, 0, x_67);
-lean_ctor_set(x_70, 1, x_68);
-return x_70;
+lean_ctor_set(x_72, 0, x_69);
+lean_ctor_set(x_72, 1, x_70);
+return x_72;
 }
 }
 }
@@ -9131,7 +9135,7 @@ return x_76;
 }
 else
 {
-uint8_t x_77; uint8_t x_78; uint8_t x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; lean_object* x_86; lean_object* x_87; 
+uint8_t x_77; uint8_t x_78; uint8_t x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; lean_object* x_87; lean_object* x_88; 
 x_77 = lean_ctor_get_uint8(x_16, 0);
 x_78 = lean_ctor_get_uint8(x_16, 1);
 x_79 = lean_ctor_get_uint8(x_16, 2);
@@ -9140,199 +9144,201 @@ x_81 = lean_ctor_get_uint8(x_16, 4);
 x_82 = lean_ctor_get_uint8(x_16, 6);
 x_83 = lean_ctor_get_uint8(x_16, 7);
 x_84 = lean_ctor_get_uint8(x_16, 8);
+x_85 = lean_ctor_get_uint8(x_16, 9);
 lean_dec(x_16);
-x_85 = 2;
-x_86 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_86, 0, x_77);
-lean_ctor_set_uint8(x_86, 1, x_78);
-lean_ctor_set_uint8(x_86, 2, x_79);
-lean_ctor_set_uint8(x_86, 3, x_80);
-lean_ctor_set_uint8(x_86, 4, x_81);
-lean_ctor_set_uint8(x_86, 5, x_85);
-lean_ctor_set_uint8(x_86, 6, x_82);
-lean_ctor_set_uint8(x_86, 7, x_83);
-lean_ctor_set_uint8(x_86, 8, x_84);
-lean_ctor_set(x_4, 0, x_86);
+x_86 = 2;
+x_87 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_87, 0, x_77);
+lean_ctor_set_uint8(x_87, 1, x_78);
+lean_ctor_set_uint8(x_87, 2, x_79);
+lean_ctor_set_uint8(x_87, 3, x_80);
+lean_ctor_set_uint8(x_87, 4, x_81);
+lean_ctor_set_uint8(x_87, 5, x_86);
+lean_ctor_set_uint8(x_87, 6, x_82);
+lean_ctor_set_uint8(x_87, 7, x_83);
+lean_ctor_set_uint8(x_87, 8, x_84);
+lean_ctor_set_uint8(x_87, 9, x_85);
+lean_ctor_set(x_4, 0, x_87);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_14);
-x_87 = l_Lean_Meta_inferType(x_14, x_4, x_5, x_6, x_7, x_11);
-if (lean_obj_tag(x_87) == 0)
+x_88 = l_Lean_Meta_inferType(x_14, x_4, x_5, x_6, x_7, x_11);
+if (lean_obj_tag(x_88) == 0)
 {
-lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-x_88 = lean_ctor_get(x_87, 0);
-lean_inc(x_88);
-x_89 = lean_ctor_get(x_87, 1);
+lean_object* x_89; lean_object* x_90; lean_object* x_91; 
+x_89 = lean_ctor_get(x_88, 0);
 lean_inc(x_89);
-lean_dec(x_87);
+x_90 = lean_ctor_get(x_88, 1);
+lean_inc(x_90);
+lean_dec(x_88);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_88);
-x_90 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_checkTypeIsProp(x_88, x_4, x_5, x_6, x_7, x_89);
-if (lean_obj_tag(x_90) == 0)
+lean_inc(x_89);
+x_91 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_checkTypeIsProp(x_89, x_4, x_5, x_6, x_7, x_90);
+if (lean_obj_tag(x_91) == 0)
 {
-lean_object* x_91; lean_object* x_92; lean_object* x_93; 
-x_91 = lean_ctor_get(x_90, 1);
-lean_inc(x_91);
-lean_dec(x_90);
-x_92 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_shouldPreprocess___closed__1;
+lean_object* x_92; lean_object* x_93; lean_object* x_94; 
+x_92 = lean_ctor_get(x_91, 1);
+lean_inc(x_92);
+lean_dec(x_91);
+x_93 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_shouldPreprocess___closed__1;
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-lean_inc(x_88);
-x_93 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_88, x_92, x_4, x_5, x_6, x_7, x_91);
-if (lean_obj_tag(x_93) == 0)
+lean_inc(x_89);
+x_94 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_89, x_93, x_4, x_5, x_6, x_7, x_92);
+if (lean_obj_tag(x_94) == 0)
 {
-lean_object* x_94; uint8_t x_95; 
-x_94 = lean_ctor_get(x_93, 0);
-lean_inc(x_94);
-x_95 = lean_unbox(x_94);
+lean_object* x_95; uint8_t x_96; 
+x_95 = lean_ctor_get(x_94, 0);
+lean_inc(x_95);
+x_96 = lean_unbox(x_95);
+lean_dec(x_95);
+if (x_96 == 0)
+{
+lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+lean_dec(x_89);
+lean_dec(x_13);
+lean_dec(x_12);
+x_97 = lean_ctor_get(x_94, 1);
+lean_inc(x_97);
 lean_dec(x_94);
-if (x_95 == 0)
-{
-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_dec(x_88);
-lean_dec(x_13);
-lean_dec(x_12);
-x_96 = lean_ctor_get(x_93, 1);
-lean_inc(x_96);
-lean_dec(x_93);
-x_97 = lean_box(0);
+x_98 = lean_box(0);
 lean_inc(x_1);
-x_98 = l_Lean_mkConst(x_1, x_97);
-x_99 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_99, 0, x_1);
-x_100 = l_Array_empty___closed__1;
-x_101 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmaCore(x_14, x_100, x_98, x_2, x_3, x_99, x_4, x_5, x_6, x_7, x_96);
-if (lean_obj_tag(x_101) == 0)
+x_99 = l_Lean_mkConst(x_1, x_98);
+x_100 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_100, 0, x_1);
+x_101 = l_Array_empty___closed__1;
+x_102 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmaCore(x_14, x_101, x_99, x_2, x_3, x_100, x_4, x_5, x_6, x_7, x_97);
+if (lean_obj_tag(x_102) == 0)
 {
-lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; 
-x_102 = lean_ctor_get(x_101, 0);
-lean_inc(x_102);
-x_103 = lean_ctor_get(x_101, 1);
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
+x_103 = lean_ctor_get(x_102, 0);
 lean_inc(x_103);
-if (lean_is_exclusive(x_101)) {
- lean_ctor_release(x_101, 0);
- lean_ctor_release(x_101, 1);
- x_104 = x_101;
+x_104 = lean_ctor_get(x_102, 1);
+lean_inc(x_104);
+if (lean_is_exclusive(x_102)) {
+ lean_ctor_release(x_102, 0);
+ lean_ctor_release(x_102, 1);
+ x_105 = x_102;
 } else {
- lean_dec_ref(x_101);
- x_104 = lean_box(0);
+ lean_dec_ref(x_102);
+ x_105 = lean_box(0);
 }
-x_105 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
-x_106 = lean_array_push(x_105, x_102);
-if (lean_is_scalar(x_104)) {
- x_107 = lean_alloc_ctor(0, 2, 0);
+x_106 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+x_107 = lean_array_push(x_106, x_103);
+if (lean_is_scalar(x_105)) {
+ x_108 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_107 = x_104;
+ x_108 = x_105;
 }
-lean_ctor_set(x_107, 0, x_106);
-lean_ctor_set(x_107, 1, x_103);
-return x_107;
+lean_ctor_set(x_108, 0, x_107);
+lean_ctor_set(x_108, 1, x_104);
+return x_108;
 }
 else
 {
-lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; 
-x_108 = lean_ctor_get(x_101, 0);
-lean_inc(x_108);
-x_109 = lean_ctor_get(x_101, 1);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
+x_109 = lean_ctor_get(x_102, 0);
 lean_inc(x_109);
-if (lean_is_exclusive(x_101)) {
- lean_ctor_release(x_101, 0);
- lean_ctor_release(x_101, 1);
- x_110 = x_101;
+x_110 = lean_ctor_get(x_102, 1);
+lean_inc(x_110);
+if (lean_is_exclusive(x_102)) {
+ lean_ctor_release(x_102, 0);
+ lean_ctor_release(x_102, 1);
+ x_111 = x_102;
 } else {
- lean_dec_ref(x_101);
- x_110 = lean_box(0);
+ lean_dec_ref(x_102);
+ x_111 = lean_box(0);
 }
-if (lean_is_scalar(x_110)) {
- x_111 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_111)) {
+ x_112 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_111 = x_110;
+ x_112 = x_111;
 }
-lean_ctor_set(x_111, 0, x_108);
-lean_ctor_set(x_111, 1, x_109);
-return x_111;
+lean_ctor_set(x_112, 0, x_109);
+lean_ctor_set(x_112, 1, x_110);
+return x_112;
 }
 }
 else
 {
-lean_object* x_112; lean_object* x_113; 
-x_112 = lean_ctor_get(x_93, 1);
-lean_inc(x_112);
-lean_dec(x_93);
+lean_object* x_113; lean_object* x_114; 
+x_113 = lean_ctor_get(x_94, 1);
+lean_inc(x_113);
+lean_dec(x_94);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_113 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess(x_14, x_88, x_4, x_5, x_6, x_7, x_112);
-if (lean_obj_tag(x_113) == 0)
+x_114 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess(x_14, x_89, x_4, x_5, x_6, x_7, x_113);
+if (lean_obj_tag(x_114) == 0)
 {
-lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
-x_114 = lean_ctor_get(x_113, 0);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_113, 1);
+lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
+x_115 = lean_ctor_get(x_114, 0);
 lean_inc(x_115);
-lean_dec(x_113);
-x_116 = l_Array_empty___closed__1;
-x_117 = l_List_forIn_loop___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmasFromConst___spec__1(x_1, x_2, x_3, x_12, x_13, x_114, x_116, x_4, x_5, x_6, x_7, x_115);
-if (lean_obj_tag(x_117) == 0)
+x_116 = lean_ctor_get(x_114, 1);
+lean_inc(x_116);
+lean_dec(x_114);
+x_117 = l_Array_empty___closed__1;
+x_118 = l_List_forIn_loop___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmasFromConst___spec__1(x_1, x_2, x_3, x_12, x_13, x_115, x_117, x_4, x_5, x_6, x_7, x_116);
+if (lean_obj_tag(x_118) == 0)
 {
-lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
-x_118 = lean_ctor_get(x_117, 0);
-lean_inc(x_118);
-x_119 = lean_ctor_get(x_117, 1);
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; 
+x_119 = lean_ctor_get(x_118, 0);
 lean_inc(x_119);
-if (lean_is_exclusive(x_117)) {
- lean_ctor_release(x_117, 0);
- lean_ctor_release(x_117, 1);
- x_120 = x_117;
+x_120 = lean_ctor_get(x_118, 1);
+lean_inc(x_120);
+if (lean_is_exclusive(x_118)) {
+ lean_ctor_release(x_118, 0);
+ lean_ctor_release(x_118, 1);
+ x_121 = x_118;
 } else {
- lean_dec_ref(x_117);
- x_120 = lean_box(0);
+ lean_dec_ref(x_118);
+ x_121 = lean_box(0);
 }
-if (lean_is_scalar(x_120)) {
- x_121 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_121)) {
+ x_122 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_121 = x_120;
+ x_122 = x_121;
 }
-lean_ctor_set(x_121, 0, x_118);
-lean_ctor_set(x_121, 1, x_119);
-return x_121;
+lean_ctor_set(x_122, 0, x_119);
+lean_ctor_set(x_122, 1, x_120);
+return x_122;
 }
 else
 {
-lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; 
-x_122 = lean_ctor_get(x_117, 0);
-lean_inc(x_122);
-x_123 = lean_ctor_get(x_117, 1);
+lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; 
+x_123 = lean_ctor_get(x_118, 0);
 lean_inc(x_123);
-if (lean_is_exclusive(x_117)) {
- lean_ctor_release(x_117, 0);
- lean_ctor_release(x_117, 1);
- x_124 = x_117;
+x_124 = lean_ctor_get(x_118, 1);
+lean_inc(x_124);
+if (lean_is_exclusive(x_118)) {
+ lean_ctor_release(x_118, 0);
+ lean_ctor_release(x_118, 1);
+ x_125 = x_118;
 } else {
- lean_dec_ref(x_117);
- x_124 = lean_box(0);
+ lean_dec_ref(x_118);
+ x_125 = lean_box(0);
 }
-if (lean_is_scalar(x_124)) {
- x_125 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_125)) {
+ x_126 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_125 = x_124;
+ x_126 = x_125;
 }
-lean_ctor_set(x_125, 0, x_122);
-lean_ctor_set(x_125, 1, x_123);
-return x_125;
+lean_ctor_set(x_126, 0, x_123);
+lean_ctor_set(x_126, 1, x_124);
+return x_126;
 }
 }
 else
 {
-lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; 
+lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; 
 lean_dec(x_4);
 lean_dec(x_13);
 lean_dec(x_12);
@@ -9341,33 +9347,33 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_1);
-x_126 = lean_ctor_get(x_113, 0);
-lean_inc(x_126);
-x_127 = lean_ctor_get(x_113, 1);
+x_127 = lean_ctor_get(x_114, 0);
 lean_inc(x_127);
-if (lean_is_exclusive(x_113)) {
- lean_ctor_release(x_113, 0);
- lean_ctor_release(x_113, 1);
- x_128 = x_113;
+x_128 = lean_ctor_get(x_114, 1);
+lean_inc(x_128);
+if (lean_is_exclusive(x_114)) {
+ lean_ctor_release(x_114, 0);
+ lean_ctor_release(x_114, 1);
+ x_129 = x_114;
 } else {
- lean_dec_ref(x_113);
- x_128 = lean_box(0);
+ lean_dec_ref(x_114);
+ x_129 = lean_box(0);
 }
-if (lean_is_scalar(x_128)) {
- x_129 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_129)) {
+ x_130 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_129 = x_128;
+ x_130 = x_129;
 }
-lean_ctor_set(x_129, 0, x_126);
-lean_ctor_set(x_129, 1, x_127);
-return x_129;
+lean_ctor_set(x_130, 0, x_127);
+lean_ctor_set(x_130, 1, x_128);
+return x_130;
 }
 }
 }
 else
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-lean_dec(x_88);
+lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; 
+lean_dec(x_89);
 lean_dec(x_4);
 lean_dec(x_14);
 lean_dec(x_13);
@@ -9377,32 +9383,32 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_1);
-x_130 = lean_ctor_get(x_93, 0);
-lean_inc(x_130);
-x_131 = lean_ctor_get(x_93, 1);
+x_131 = lean_ctor_get(x_94, 0);
 lean_inc(x_131);
-if (lean_is_exclusive(x_93)) {
- lean_ctor_release(x_93, 0);
- lean_ctor_release(x_93, 1);
- x_132 = x_93;
+x_132 = lean_ctor_get(x_94, 1);
+lean_inc(x_132);
+if (lean_is_exclusive(x_94)) {
+ lean_ctor_release(x_94, 0);
+ lean_ctor_release(x_94, 1);
+ x_133 = x_94;
 } else {
- lean_dec_ref(x_93);
- x_132 = lean_box(0);
+ lean_dec_ref(x_94);
+ x_133 = lean_box(0);
 }
-if (lean_is_scalar(x_132)) {
- x_133 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_133)) {
+ x_134 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_133 = x_132;
+ x_134 = x_133;
 }
-lean_ctor_set(x_133, 0, x_130);
-lean_ctor_set(x_133, 1, x_131);
-return x_133;
+lean_ctor_set(x_134, 0, x_131);
+lean_ctor_set(x_134, 1, x_132);
+return x_134;
 }
 }
 else
 {
-lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; 
-lean_dec(x_88);
+lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; 
+lean_dec(x_89);
 lean_dec(x_4);
 lean_dec(x_14);
 lean_dec(x_13);
@@ -9412,31 +9418,31 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_1);
-x_134 = lean_ctor_get(x_90, 0);
-lean_inc(x_134);
-x_135 = lean_ctor_get(x_90, 1);
+x_135 = lean_ctor_get(x_91, 0);
 lean_inc(x_135);
-if (lean_is_exclusive(x_90)) {
- lean_ctor_release(x_90, 0);
- lean_ctor_release(x_90, 1);
- x_136 = x_90;
+x_136 = lean_ctor_get(x_91, 1);
+lean_inc(x_136);
+if (lean_is_exclusive(x_91)) {
+ lean_ctor_release(x_91, 0);
+ lean_ctor_release(x_91, 1);
+ x_137 = x_91;
 } else {
- lean_dec_ref(x_90);
- x_136 = lean_box(0);
+ lean_dec_ref(x_91);
+ x_137 = lean_box(0);
 }
-if (lean_is_scalar(x_136)) {
- x_137 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_137)) {
+ x_138 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_137 = x_136;
+ x_138 = x_137;
 }
-lean_ctor_set(x_137, 0, x_134);
-lean_ctor_set(x_137, 1, x_135);
-return x_137;
+lean_ctor_set(x_138, 0, x_135);
+lean_ctor_set(x_138, 1, x_136);
+return x_138;
 }
 }
 else
 {
-lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
+lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; 
 lean_dec(x_4);
 lean_dec(x_14);
 lean_dec(x_13);
@@ -9446,292 +9452,258 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_1);
-x_138 = lean_ctor_get(x_87, 0);
-lean_inc(x_138);
-x_139 = lean_ctor_get(x_87, 1);
+x_139 = lean_ctor_get(x_88, 0);
 lean_inc(x_139);
-if (lean_is_exclusive(x_87)) {
- lean_ctor_release(x_87, 0);
- lean_ctor_release(x_87, 1);
- x_140 = x_87;
+x_140 = lean_ctor_get(x_88, 1);
+lean_inc(x_140);
+if (lean_is_exclusive(x_88)) {
+ lean_ctor_release(x_88, 0);
+ lean_ctor_release(x_88, 1);
+ x_141 = x_88;
 } else {
- lean_dec_ref(x_87);
- x_140 = lean_box(0);
+ lean_dec_ref(x_88);
+ x_141 = lean_box(0);
 }
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_141)) {
+ x_142 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_141 = x_140;
+ x_142 = x_141;
 }
-lean_ctor_set(x_141, 0, x_138);
-lean_ctor_set(x_141, 1, x_139);
-return x_141;
+lean_ctor_set(x_142, 0, x_139);
+lean_ctor_set(x_142, 1, x_140);
+return x_142;
 }
 }
 }
 else
 {
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; uint8_t x_146; uint8_t x_147; uint8_t x_148; uint8_t x_149; uint8_t x_150; uint8_t x_151; uint8_t x_152; uint8_t x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; 
-x_142 = lean_ctor_get(x_4, 0);
-x_143 = lean_ctor_get(x_4, 1);
-x_144 = lean_ctor_get(x_4, 2);
-x_145 = lean_ctor_get(x_4, 3);
+lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; uint8_t x_148; uint8_t x_149; uint8_t x_150; uint8_t x_151; uint8_t x_152; uint8_t x_153; uint8_t x_154; uint8_t x_155; lean_object* x_156; uint8_t x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; 
+x_143 = lean_ctor_get(x_4, 0);
+x_144 = lean_ctor_get(x_4, 1);
+x_145 = lean_ctor_get(x_4, 2);
+x_146 = lean_ctor_get(x_4, 3);
+lean_inc(x_146);
 lean_inc(x_145);
 lean_inc(x_144);
 lean_inc(x_143);
-lean_inc(x_142);
 lean_dec(x_4);
-x_146 = lean_ctor_get_uint8(x_142, 0);
-x_147 = lean_ctor_get_uint8(x_142, 1);
-x_148 = lean_ctor_get_uint8(x_142, 2);
-x_149 = lean_ctor_get_uint8(x_142, 3);
-x_150 = lean_ctor_get_uint8(x_142, 4);
-x_151 = lean_ctor_get_uint8(x_142, 6);
-x_152 = lean_ctor_get_uint8(x_142, 7);
-x_153 = lean_ctor_get_uint8(x_142, 8);
-if (lean_is_exclusive(x_142)) {
- x_154 = x_142;
+x_147 = lean_ctor_get_uint8(x_143, 0);
+x_148 = lean_ctor_get_uint8(x_143, 1);
+x_149 = lean_ctor_get_uint8(x_143, 2);
+x_150 = lean_ctor_get_uint8(x_143, 3);
+x_151 = lean_ctor_get_uint8(x_143, 4);
+x_152 = lean_ctor_get_uint8(x_143, 6);
+x_153 = lean_ctor_get_uint8(x_143, 7);
+x_154 = lean_ctor_get_uint8(x_143, 8);
+x_155 = lean_ctor_get_uint8(x_143, 9);
+if (lean_is_exclusive(x_143)) {
+ x_156 = x_143;
 } else {
- lean_dec_ref(x_142);
- x_154 = lean_box(0);
+ lean_dec_ref(x_143);
+ x_156 = lean_box(0);
 }
-x_155 = 2;
-if (lean_is_scalar(x_154)) {
- x_156 = lean_alloc_ctor(0, 0, 9);
+x_157 = 2;
+if (lean_is_scalar(x_156)) {
+ x_158 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_156 = x_154;
+ x_158 = x_156;
 }
-lean_ctor_set_uint8(x_156, 0, x_146);
-lean_ctor_set_uint8(x_156, 1, x_147);
-lean_ctor_set_uint8(x_156, 2, x_148);
-lean_ctor_set_uint8(x_156, 3, x_149);
-lean_ctor_set_uint8(x_156, 4, x_150);
-lean_ctor_set_uint8(x_156, 5, x_155);
-lean_ctor_set_uint8(x_156, 6, x_151);
-lean_ctor_set_uint8(x_156, 7, x_152);
-lean_ctor_set_uint8(x_156, 8, x_153);
-x_157 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_157, 0, x_156);
-lean_ctor_set(x_157, 1, x_143);
-lean_ctor_set(x_157, 2, x_144);
-lean_ctor_set(x_157, 3, x_145);
+lean_ctor_set_uint8(x_158, 0, x_147);
+lean_ctor_set_uint8(x_158, 1, x_148);
+lean_ctor_set_uint8(x_158, 2, x_149);
+lean_ctor_set_uint8(x_158, 3, x_150);
+lean_ctor_set_uint8(x_158, 4, x_151);
+lean_ctor_set_uint8(x_158, 5, x_157);
+lean_ctor_set_uint8(x_158, 6, x_152);
+lean_ctor_set_uint8(x_158, 7, x_153);
+lean_ctor_set_uint8(x_158, 8, x_154);
+lean_ctor_set_uint8(x_158, 9, x_155);
+x_159 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_159, 0, x_158);
+lean_ctor_set(x_159, 1, x_144);
+lean_ctor_set(x_159, 2, x_145);
+lean_ctor_set(x_159, 3, x_146);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_157);
+lean_inc(x_159);
 lean_inc(x_14);
-x_158 = l_Lean_Meta_inferType(x_14, x_157, x_5, x_6, x_7, x_11);
-if (lean_obj_tag(x_158) == 0)
+x_160 = l_Lean_Meta_inferType(x_14, x_159, x_5, x_6, x_7, x_11);
+if (lean_obj_tag(x_160) == 0)
 {
-lean_object* x_159; lean_object* x_160; lean_object* x_161; 
-x_159 = lean_ctor_get(x_158, 0);
-lean_inc(x_159);
-x_160 = lean_ctor_get(x_158, 1);
-lean_inc(x_160);
-lean_dec(x_158);
-lean_inc(x_7);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_157);
-lean_inc(x_159);
-x_161 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_checkTypeIsProp(x_159, x_157, x_5, x_6, x_7, x_160);
-if (lean_obj_tag(x_161) == 0)
-{
-lean_object* x_162; lean_object* x_163; lean_object* x_164; 
-x_162 = lean_ctor_get(x_161, 1);
+lean_object* x_161; lean_object* x_162; lean_object* x_163; 
+x_161 = lean_ctor_get(x_160, 0);
+lean_inc(x_161);
+x_162 = lean_ctor_get(x_160, 1);
 lean_inc(x_162);
-lean_dec(x_161);
-x_163 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_shouldPreprocess___closed__1;
+lean_dec(x_160);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_157);
 lean_inc(x_159);
-x_164 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_159, x_163, x_157, x_5, x_6, x_7, x_162);
-if (lean_obj_tag(x_164) == 0)
+lean_inc(x_161);
+x_163 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_checkTypeIsProp(x_161, x_159, x_5, x_6, x_7, x_162);
+if (lean_obj_tag(x_163) == 0)
 {
-lean_object* x_165; uint8_t x_166; 
-x_165 = lean_ctor_get(x_164, 0);
-lean_inc(x_165);
-x_166 = lean_unbox(x_165);
-lean_dec(x_165);
-if (x_166 == 0)
-{
-lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; 
-lean_dec(x_159);
-lean_dec(x_13);
-lean_dec(x_12);
-x_167 = lean_ctor_get(x_164, 1);
-lean_inc(x_167);
-lean_dec(x_164);
-x_168 = lean_box(0);
-lean_inc(x_1);
-x_169 = l_Lean_mkConst(x_1, x_168);
-x_170 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_170, 0, x_1);
-x_171 = l_Array_empty___closed__1;
-x_172 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmaCore(x_14, x_171, x_169, x_2, x_3, x_170, x_157, x_5, x_6, x_7, x_167);
-if (lean_obj_tag(x_172) == 0)
-{
-lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; 
-x_173 = lean_ctor_get(x_172, 0);
-lean_inc(x_173);
-x_174 = lean_ctor_get(x_172, 1);
-lean_inc(x_174);
-if (lean_is_exclusive(x_172)) {
- lean_ctor_release(x_172, 0);
- lean_ctor_release(x_172, 1);
- x_175 = x_172;
-} else {
- lean_dec_ref(x_172);
- x_175 = lean_box(0);
-}
-x_176 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
-x_177 = lean_array_push(x_176, x_173);
-if (lean_is_scalar(x_175)) {
- x_178 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_178 = x_175;
-}
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set(x_178, 1, x_174);
-return x_178;
-}
-else
-{
-lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; 
-x_179 = lean_ctor_get(x_172, 0);
-lean_inc(x_179);
-x_180 = lean_ctor_get(x_172, 1);
-lean_inc(x_180);
-if (lean_is_exclusive(x_172)) {
- lean_ctor_release(x_172, 0);
- lean_ctor_release(x_172, 1);
- x_181 = x_172;
-} else {
- lean_dec_ref(x_172);
- x_181 = lean_box(0);
-}
-if (lean_is_scalar(x_181)) {
- x_182 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_182 = x_181;
-}
-lean_ctor_set(x_182, 0, x_179);
-lean_ctor_set(x_182, 1, x_180);
-return x_182;
-}
-}
-else
-{
-lean_object* x_183; lean_object* x_184; 
-x_183 = lean_ctor_get(x_164, 1);
-lean_inc(x_183);
-lean_dec(x_164);
+lean_object* x_164; lean_object* x_165; lean_object* x_166; 
+x_164 = lean_ctor_get(x_163, 1);
+lean_inc(x_164);
+lean_dec(x_163);
+x_165 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_shouldPreprocess___closed__1;
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-lean_inc(x_157);
-x_184 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess(x_14, x_159, x_157, x_5, x_6, x_7, x_183);
-if (lean_obj_tag(x_184) == 0)
+lean_inc(x_159);
+lean_inc(x_161);
+x_166 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_161, x_165, x_159, x_5, x_6, x_7, x_164);
+if (lean_obj_tag(x_166) == 0)
 {
-lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; 
-x_185 = lean_ctor_get(x_184, 0);
+lean_object* x_167; uint8_t x_168; 
+x_167 = lean_ctor_get(x_166, 0);
+lean_inc(x_167);
+x_168 = lean_unbox(x_167);
+lean_dec(x_167);
+if (x_168 == 0)
+{
+lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; 
+lean_dec(x_161);
+lean_dec(x_13);
+lean_dec(x_12);
+x_169 = lean_ctor_get(x_166, 1);
+lean_inc(x_169);
+lean_dec(x_166);
+x_170 = lean_box(0);
+lean_inc(x_1);
+x_171 = l_Lean_mkConst(x_1, x_170);
+x_172 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_172, 0, x_1);
+x_173 = l_Array_empty___closed__1;
+x_174 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmaCore(x_14, x_173, x_171, x_2, x_3, x_172, x_159, x_5, x_6, x_7, x_169);
+if (lean_obj_tag(x_174) == 0)
+{
+lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; 
+x_175 = lean_ctor_get(x_174, 0);
+lean_inc(x_175);
+x_176 = lean_ctor_get(x_174, 1);
+lean_inc(x_176);
+if (lean_is_exclusive(x_174)) {
+ lean_ctor_release(x_174, 0);
+ lean_ctor_release(x_174, 1);
+ x_177 = x_174;
+} else {
+ lean_dec_ref(x_174);
+ x_177 = lean_box(0);
+}
+x_178 = l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+x_179 = lean_array_push(x_178, x_175);
+if (lean_is_scalar(x_177)) {
+ x_180 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_180 = x_177;
+}
+lean_ctor_set(x_180, 0, x_179);
+lean_ctor_set(x_180, 1, x_176);
+return x_180;
+}
+else
+{
+lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; 
+x_181 = lean_ctor_get(x_174, 0);
+lean_inc(x_181);
+x_182 = lean_ctor_get(x_174, 1);
+lean_inc(x_182);
+if (lean_is_exclusive(x_174)) {
+ lean_ctor_release(x_174, 0);
+ lean_ctor_release(x_174, 1);
+ x_183 = x_174;
+} else {
+ lean_dec_ref(x_174);
+ x_183 = lean_box(0);
+}
+if (lean_is_scalar(x_183)) {
+ x_184 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_184 = x_183;
+}
+lean_ctor_set(x_184, 0, x_181);
+lean_ctor_set(x_184, 1, x_182);
+return x_184;
+}
+}
+else
+{
+lean_object* x_185; lean_object* x_186; 
+x_185 = lean_ctor_get(x_166, 1);
 lean_inc(x_185);
-x_186 = lean_ctor_get(x_184, 1);
-lean_inc(x_186);
-lean_dec(x_184);
-x_187 = l_Array_empty___closed__1;
-x_188 = l_List_forIn_loop___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmasFromConst___spec__1(x_1, x_2, x_3, x_12, x_13, x_185, x_187, x_157, x_5, x_6, x_7, x_186);
-if (lean_obj_tag(x_188) == 0)
+lean_dec(x_166);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_159);
+x_186 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocess(x_14, x_161, x_159, x_5, x_6, x_7, x_185);
+if (lean_obj_tag(x_186) == 0)
 {
-lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; 
-x_189 = lean_ctor_get(x_188, 0);
-lean_inc(x_189);
-x_190 = lean_ctor_get(x_188, 1);
-lean_inc(x_190);
-if (lean_is_exclusive(x_188)) {
- lean_ctor_release(x_188, 0);
- lean_ctor_release(x_188, 1);
- x_191 = x_188;
+lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; 
+x_187 = lean_ctor_get(x_186, 0);
+lean_inc(x_187);
+x_188 = lean_ctor_get(x_186, 1);
+lean_inc(x_188);
+lean_dec(x_186);
+x_189 = l_Array_empty___closed__1;
+x_190 = l_List_forIn_loop___at___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_mkSimpLemmasFromConst___spec__1(x_1, x_2, x_3, x_12, x_13, x_187, x_189, x_159, x_5, x_6, x_7, x_188);
+if (lean_obj_tag(x_190) == 0)
+{
+lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; 
+x_191 = lean_ctor_get(x_190, 0);
+lean_inc(x_191);
+x_192 = lean_ctor_get(x_190, 1);
+lean_inc(x_192);
+if (lean_is_exclusive(x_190)) {
+ lean_ctor_release(x_190, 0);
+ lean_ctor_release(x_190, 1);
+ x_193 = x_190;
 } else {
- lean_dec_ref(x_188);
- x_191 = lean_box(0);
+ lean_dec_ref(x_190);
+ x_193 = lean_box(0);
 }
-if (lean_is_scalar(x_191)) {
- x_192 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_193)) {
+ x_194 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_192 = x_191;
+ x_194 = x_193;
 }
-lean_ctor_set(x_192, 0, x_189);
-lean_ctor_set(x_192, 1, x_190);
-return x_192;
+lean_ctor_set(x_194, 0, x_191);
+lean_ctor_set(x_194, 1, x_192);
+return x_194;
 }
 else
 {
-lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; 
-x_193 = lean_ctor_get(x_188, 0);
-lean_inc(x_193);
-x_194 = lean_ctor_get(x_188, 1);
-lean_inc(x_194);
-if (lean_is_exclusive(x_188)) {
- lean_ctor_release(x_188, 0);
- lean_ctor_release(x_188, 1);
- x_195 = x_188;
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; 
+x_195 = lean_ctor_get(x_190, 0);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_190, 1);
+lean_inc(x_196);
+if (lean_is_exclusive(x_190)) {
+ lean_ctor_release(x_190, 0);
+ lean_ctor_release(x_190, 1);
+ x_197 = x_190;
 } else {
- lean_dec_ref(x_188);
- x_195 = lean_box(0);
+ lean_dec_ref(x_190);
+ x_197 = lean_box(0);
 }
-if (lean_is_scalar(x_195)) {
- x_196 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_197)) {
+ x_198 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_196 = x_195;
+ x_198 = x_197;
 }
-lean_ctor_set(x_196, 0, x_193);
-lean_ctor_set(x_196, 1, x_194);
-return x_196;
+lean_ctor_set(x_198, 0, x_195);
+lean_ctor_set(x_198, 1, x_196);
+return x_198;
 }
 }
 else
 {
-lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; 
-lean_dec(x_157);
-lean_dec(x_13);
-lean_dec(x_12);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_3);
-lean_dec(x_1);
-x_197 = lean_ctor_get(x_184, 0);
-lean_inc(x_197);
-x_198 = lean_ctor_get(x_184, 1);
-lean_inc(x_198);
-if (lean_is_exclusive(x_184)) {
- lean_ctor_release(x_184, 0);
- lean_ctor_release(x_184, 1);
- x_199 = x_184;
-} else {
- lean_dec_ref(x_184);
- x_199 = lean_box(0);
-}
-if (lean_is_scalar(x_199)) {
- x_200 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_200 = x_199;
-}
-lean_ctor_set(x_200, 0, x_197);
-lean_ctor_set(x_200, 1, x_198);
-return x_200;
-}
-}
-}
-else
-{
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; 
+lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; 
 lean_dec(x_159);
-lean_dec(x_157);
-lean_dec(x_14);
 lean_dec(x_13);
 lean_dec(x_12);
 lean_dec(x_7);
@@ -9739,33 +9711,34 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_1);
-x_201 = lean_ctor_get(x_164, 0);
-lean_inc(x_201);
-x_202 = lean_ctor_get(x_164, 1);
-lean_inc(x_202);
-if (lean_is_exclusive(x_164)) {
- lean_ctor_release(x_164, 0);
- lean_ctor_release(x_164, 1);
- x_203 = x_164;
+x_199 = lean_ctor_get(x_186, 0);
+lean_inc(x_199);
+x_200 = lean_ctor_get(x_186, 1);
+lean_inc(x_200);
+if (lean_is_exclusive(x_186)) {
+ lean_ctor_release(x_186, 0);
+ lean_ctor_release(x_186, 1);
+ x_201 = x_186;
 } else {
- lean_dec_ref(x_164);
- x_203 = lean_box(0);
+ lean_dec_ref(x_186);
+ x_201 = lean_box(0);
 }
-if (lean_is_scalar(x_203)) {
- x_204 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_201)) {
+ x_202 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_204 = x_203;
+ x_202 = x_201;
+}
+lean_ctor_set(x_202, 0, x_199);
+lean_ctor_set(x_202, 1, x_200);
+return x_202;
 }
-lean_ctor_set(x_204, 0, x_201);
-lean_ctor_set(x_204, 1, x_202);
-return x_204;
 }
 }
 else
 {
-lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; 
+lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; 
+lean_dec(x_161);
 lean_dec(x_159);
-lean_dec(x_157);
 lean_dec(x_14);
 lean_dec(x_13);
 lean_dec(x_12);
@@ -9774,32 +9747,33 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_1);
-x_205 = lean_ctor_get(x_161, 0);
-lean_inc(x_205);
-x_206 = lean_ctor_get(x_161, 1);
-lean_inc(x_206);
-if (lean_is_exclusive(x_161)) {
- lean_ctor_release(x_161, 0);
- lean_ctor_release(x_161, 1);
- x_207 = x_161;
+x_203 = lean_ctor_get(x_166, 0);
+lean_inc(x_203);
+x_204 = lean_ctor_get(x_166, 1);
+lean_inc(x_204);
+if (lean_is_exclusive(x_166)) {
+ lean_ctor_release(x_166, 0);
+ lean_ctor_release(x_166, 1);
+ x_205 = x_166;
 } else {
- lean_dec_ref(x_161);
- x_207 = lean_box(0);
+ lean_dec_ref(x_166);
+ x_205 = lean_box(0);
 }
-if (lean_is_scalar(x_207)) {
- x_208 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_205)) {
+ x_206 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_208 = x_207;
+ x_206 = x_205;
 }
-lean_ctor_set(x_208, 0, x_205);
-lean_ctor_set(x_208, 1, x_206);
-return x_208;
+lean_ctor_set(x_206, 0, x_203);
+lean_ctor_set(x_206, 1, x_204);
+return x_206;
 }
 }
 else
 {
-lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; 
-lean_dec(x_157);
+lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; 
+lean_dec(x_161);
+lean_dec(x_159);
 lean_dec(x_14);
 lean_dec(x_13);
 lean_dec(x_12);
@@ -9808,55 +9782,89 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_1);
-x_209 = lean_ctor_get(x_158, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_158, 1);
-lean_inc(x_210);
-if (lean_is_exclusive(x_158)) {
- lean_ctor_release(x_158, 0);
- lean_ctor_release(x_158, 1);
- x_211 = x_158;
+x_207 = lean_ctor_get(x_163, 0);
+lean_inc(x_207);
+x_208 = lean_ctor_get(x_163, 1);
+lean_inc(x_208);
+if (lean_is_exclusive(x_163)) {
+ lean_ctor_release(x_163, 0);
+ lean_ctor_release(x_163, 1);
+ x_209 = x_163;
 } else {
- lean_dec_ref(x_158);
- x_211 = lean_box(0);
+ lean_dec_ref(x_163);
+ x_209 = lean_box(0);
 }
-if (lean_is_scalar(x_211)) {
- x_212 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_209)) {
+ x_210 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_212 = x_211;
+ x_210 = x_209;
 }
-lean_ctor_set(x_212, 0, x_209);
-lean_ctor_set(x_212, 1, x_210);
-return x_212;
+lean_ctor_set(x_210, 0, x_207);
+lean_ctor_set(x_210, 1, x_208);
+return x_210;
+}
+}
+else
+{
+lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; 
+lean_dec(x_159);
+lean_dec(x_14);
+lean_dec(x_13);
+lean_dec(x_12);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_1);
+x_211 = lean_ctor_get(x_160, 0);
+lean_inc(x_211);
+x_212 = lean_ctor_get(x_160, 1);
+lean_inc(x_212);
+if (lean_is_exclusive(x_160)) {
+ lean_ctor_release(x_160, 0);
+ lean_ctor_release(x_160, 1);
+ x_213 = x_160;
+} else {
+ lean_dec_ref(x_160);
+ x_213 = lean_box(0);
+}
+if (lean_is_scalar(x_213)) {
+ x_214 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_214 = x_213;
+}
+lean_ctor_set(x_214, 0, x_211);
+lean_ctor_set(x_214, 1, x_212);
+return x_214;
 }
 }
 }
 else
 {
-uint8_t x_213; 
+uint8_t x_215; 
 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_213 = !lean_is_exclusive(x_9);
-if (x_213 == 0)
+x_215 = !lean_is_exclusive(x_9);
+if (x_215 == 0)
 {
 return x_9;
 }
 else
 {
-lean_object* x_214; lean_object* x_215; lean_object* x_216; 
-x_214 = lean_ctor_get(x_9, 0);
-x_215 = lean_ctor_get(x_9, 1);
-lean_inc(x_215);
-lean_inc(x_214);
+lean_object* x_216; lean_object* x_217; lean_object* x_218; 
+x_216 = lean_ctor_get(x_9, 0);
+x_217 = lean_ctor_get(x_9, 1);
+lean_inc(x_217);
+lean_inc(x_216);
 lean_dec(x_9);
-x_216 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_216, 0, x_214);
-lean_ctor_set(x_216, 1, x_215);
-return x_216;
+x_218 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_218, 0, x_216);
+lean_ctor_set(x_218, 1, x_217);
+return x_218;
 }
 }
 }
@@ -12192,7 +12200,7 @@ return x_38;
 }
 else
 {
-uint8_t x_39; uint8_t x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; lean_object* x_48; lean_object* x_49; 
+uint8_t x_39; uint8_t x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; 
 x_39 = lean_ctor_get_uint8(x_12, 0);
 x_40 = lean_ctor_get_uint8(x_12, 1);
 x_41 = lean_ctor_get_uint8(x_12, 2);
@@ -12201,101 +12209,103 @@ x_43 = lean_ctor_get_uint8(x_12, 4);
 x_44 = lean_ctor_get_uint8(x_12, 6);
 x_45 = lean_ctor_get_uint8(x_12, 7);
 x_46 = lean_ctor_get_uint8(x_12, 8);
+x_47 = lean_ctor_get_uint8(x_12, 9);
 lean_dec(x_12);
-x_47 = 2;
-x_48 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_48, 0, x_39);
-lean_ctor_set_uint8(x_48, 1, x_40);
-lean_ctor_set_uint8(x_48, 2, x_41);
-lean_ctor_set_uint8(x_48, 3, x_42);
-lean_ctor_set_uint8(x_48, 4, x_43);
-lean_ctor_set_uint8(x_48, 5, x_47);
-lean_ctor_set_uint8(x_48, 6, x_44);
-lean_ctor_set_uint8(x_48, 7, x_45);
-lean_ctor_set_uint8(x_48, 8, x_46);
-lean_ctor_set(x_6, 0, x_48);
+x_48 = 2;
+x_49 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_49, 0, x_39);
+lean_ctor_set_uint8(x_49, 1, x_40);
+lean_ctor_set_uint8(x_49, 2, x_41);
+lean_ctor_set_uint8(x_49, 3, x_42);
+lean_ctor_set_uint8(x_49, 4, x_43);
+lean_ctor_set_uint8(x_49, 5, x_48);
+lean_ctor_set_uint8(x_49, 6, x_44);
+lean_ctor_set_uint8(x_49, 7, x_45);
+lean_ctor_set_uint8(x_49, 8, x_46);
+lean_ctor_set_uint8(x_49, 9, x_47);
+lean_ctor_set(x_6, 0, x_49);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-x_49 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocessProof(x_2, x_6, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_49) == 0)
+x_50 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocessProof(x_2, x_6, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_50) == 0)
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; size_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_50 = lean_ctor_get(x_49, 0);
-lean_inc(x_50);
-x_51 = lean_ctor_get(x_49, 1);
+lean_object* x_51; lean_object* x_52; lean_object* x_53; size_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_51 = lean_ctor_get(x_50, 0);
 lean_inc(x_51);
-lean_dec(x_49);
-x_52 = lean_array_get_size(x_50);
-x_53 = lean_usize_of_nat(x_52);
-lean_dec(x_52);
-x_54 = x_50;
-x_55 = lean_box(x_3);
-x_56 = lean_box_usize(x_53);
-x_57 = l_Lean_Meta_mkSimpLemmas___boxed__const__1;
-x_58 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Meta_mkSimpLemmas___spec__1___boxed), 12, 7);
-lean_closure_set(x_58, 0, x_1);
-lean_closure_set(x_58, 1, x_55);
-lean_closure_set(x_58, 2, x_4);
-lean_closure_set(x_58, 3, x_5);
-lean_closure_set(x_58, 4, x_56);
-lean_closure_set(x_58, 5, x_57);
-lean_closure_set(x_58, 6, x_54);
-x_59 = x_58;
-x_60 = lean_apply_5(x_59, x_6, x_7, x_8, x_9, x_51);
-if (lean_obj_tag(x_60) == 0)
+x_52 = lean_ctor_get(x_50, 1);
+lean_inc(x_52);
+lean_dec(x_50);
+x_53 = lean_array_get_size(x_51);
+x_54 = lean_usize_of_nat(x_53);
+lean_dec(x_53);
+x_55 = x_51;
+x_56 = lean_box(x_3);
+x_57 = lean_box_usize(x_54);
+x_58 = l_Lean_Meta_mkSimpLemmas___boxed__const__1;
+x_59 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Meta_mkSimpLemmas___spec__1___boxed), 12, 7);
+lean_closure_set(x_59, 0, x_1);
+lean_closure_set(x_59, 1, x_56);
+lean_closure_set(x_59, 2, x_4);
+lean_closure_set(x_59, 3, x_5);
+lean_closure_set(x_59, 4, x_57);
+lean_closure_set(x_59, 5, x_58);
+lean_closure_set(x_59, 6, x_55);
+x_60 = x_59;
+x_61 = lean_apply_5(x_60, x_6, x_7, x_8, x_9, x_52);
+if (lean_obj_tag(x_61) == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = lean_ctor_get(x_60, 0);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_60, 1);
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_62 = lean_ctor_get(x_61, 0);
 lean_inc(x_62);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- lean_ctor_release(x_60, 1);
- x_63 = x_60;
+x_63 = lean_ctor_get(x_61, 1);
+lean_inc(x_63);
+if (lean_is_exclusive(x_61)) {
+ lean_ctor_release(x_61, 0);
+ lean_ctor_release(x_61, 1);
+ x_64 = x_61;
 } else {
- lean_dec_ref(x_60);
- x_63 = lean_box(0);
+ lean_dec_ref(x_61);
+ x_64 = lean_box(0);
 }
-if (lean_is_scalar(x_63)) {
- x_64 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_64)) {
+ x_65 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_64 = x_63;
+ x_65 = x_64;
 }
-lean_ctor_set(x_64, 0, x_61);
-lean_ctor_set(x_64, 1, x_62);
-return x_64;
+lean_ctor_set(x_65, 0, x_62);
+lean_ctor_set(x_65, 1, x_63);
+return x_65;
 }
 else
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_65 = lean_ctor_get(x_60, 0);
-lean_inc(x_65);
-x_66 = lean_ctor_get(x_60, 1);
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_66 = lean_ctor_get(x_61, 0);
 lean_inc(x_66);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- lean_ctor_release(x_60, 1);
- x_67 = x_60;
+x_67 = lean_ctor_get(x_61, 1);
+lean_inc(x_67);
+if (lean_is_exclusive(x_61)) {
+ lean_ctor_release(x_61, 0);
+ lean_ctor_release(x_61, 1);
+ x_68 = x_61;
 } else {
- lean_dec_ref(x_60);
- x_67 = lean_box(0);
+ lean_dec_ref(x_61);
+ x_68 = lean_box(0);
 }
-if (lean_is_scalar(x_67)) {
- x_68 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_68)) {
+ x_69 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_68 = x_67;
+ x_69 = x_68;
 }
-lean_ctor_set(x_68, 0, x_65);
-lean_ctor_set(x_68, 1, x_66);
-return x_68;
+lean_ctor_set(x_69, 0, x_66);
+lean_ctor_set(x_69, 1, x_67);
+return x_69;
 }
 }
 else
 {
-lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
 lean_dec(x_6);
 lean_dec(x_9);
 lean_dec(x_8);
@@ -12303,184 +12313,186 @@ lean_dec(x_7);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_69 = lean_ctor_get(x_49, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_49, 1);
+x_70 = lean_ctor_get(x_50, 0);
 lean_inc(x_70);
-if (lean_is_exclusive(x_49)) {
- lean_ctor_release(x_49, 0);
- lean_ctor_release(x_49, 1);
- x_71 = x_49;
+x_71 = lean_ctor_get(x_50, 1);
+lean_inc(x_71);
+if (lean_is_exclusive(x_50)) {
+ lean_ctor_release(x_50, 0);
+ lean_ctor_release(x_50, 1);
+ x_72 = x_50;
 } else {
- lean_dec_ref(x_49);
- x_71 = lean_box(0);
+ lean_dec_ref(x_50);
+ x_72 = lean_box(0);
 }
-if (lean_is_scalar(x_71)) {
- x_72 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_72)) {
+ x_73 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_72 = x_71;
+ x_73 = x_72;
 }
-lean_ctor_set(x_72, 0, x_69);
-lean_ctor_set(x_72, 1, x_70);
-return x_72;
+lean_ctor_set(x_73, 0, x_70);
+lean_ctor_set(x_73, 1, x_71);
+return x_73;
 }
 }
 }
 else
 {
-lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; uint8_t x_78; uint8_t x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; lean_object* x_85; uint8_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
-x_73 = lean_ctor_get(x_6, 0);
-x_74 = lean_ctor_get(x_6, 1);
-x_75 = lean_ctor_get(x_6, 2);
-x_76 = lean_ctor_get(x_6, 3);
+lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; uint8_t x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; uint8_t x_83; uint8_t x_84; uint8_t x_85; uint8_t x_86; lean_object* x_87; uint8_t x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
+x_74 = lean_ctor_get(x_6, 0);
+x_75 = lean_ctor_get(x_6, 1);
+x_76 = lean_ctor_get(x_6, 2);
+x_77 = lean_ctor_get(x_6, 3);
+lean_inc(x_77);
 lean_inc(x_76);
 lean_inc(x_75);
 lean_inc(x_74);
-lean_inc(x_73);
 lean_dec(x_6);
-x_77 = lean_ctor_get_uint8(x_73, 0);
-x_78 = lean_ctor_get_uint8(x_73, 1);
-x_79 = lean_ctor_get_uint8(x_73, 2);
-x_80 = lean_ctor_get_uint8(x_73, 3);
-x_81 = lean_ctor_get_uint8(x_73, 4);
-x_82 = lean_ctor_get_uint8(x_73, 6);
-x_83 = lean_ctor_get_uint8(x_73, 7);
-x_84 = lean_ctor_get_uint8(x_73, 8);
-if (lean_is_exclusive(x_73)) {
- x_85 = x_73;
+x_78 = lean_ctor_get_uint8(x_74, 0);
+x_79 = lean_ctor_get_uint8(x_74, 1);
+x_80 = lean_ctor_get_uint8(x_74, 2);
+x_81 = lean_ctor_get_uint8(x_74, 3);
+x_82 = lean_ctor_get_uint8(x_74, 4);
+x_83 = lean_ctor_get_uint8(x_74, 6);
+x_84 = lean_ctor_get_uint8(x_74, 7);
+x_85 = lean_ctor_get_uint8(x_74, 8);
+x_86 = lean_ctor_get_uint8(x_74, 9);
+if (lean_is_exclusive(x_74)) {
+ x_87 = x_74;
 } else {
- lean_dec_ref(x_73);
- x_85 = lean_box(0);
+ lean_dec_ref(x_74);
+ x_87 = lean_box(0);
 }
-x_86 = 2;
-if (lean_is_scalar(x_85)) {
- x_87 = lean_alloc_ctor(0, 0, 9);
+x_88 = 2;
+if (lean_is_scalar(x_87)) {
+ x_89 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_87 = x_85;
+ x_89 = x_87;
 }
-lean_ctor_set_uint8(x_87, 0, x_77);
-lean_ctor_set_uint8(x_87, 1, x_78);
-lean_ctor_set_uint8(x_87, 2, x_79);
-lean_ctor_set_uint8(x_87, 3, x_80);
-lean_ctor_set_uint8(x_87, 4, x_81);
-lean_ctor_set_uint8(x_87, 5, x_86);
-lean_ctor_set_uint8(x_87, 6, x_82);
-lean_ctor_set_uint8(x_87, 7, x_83);
-lean_ctor_set_uint8(x_87, 8, x_84);
-x_88 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_88, 0, x_87);
-lean_ctor_set(x_88, 1, x_74);
-lean_ctor_set(x_88, 2, x_75);
-lean_ctor_set(x_88, 3, x_76);
+lean_ctor_set_uint8(x_89, 0, x_78);
+lean_ctor_set_uint8(x_89, 1, x_79);
+lean_ctor_set_uint8(x_89, 2, x_80);
+lean_ctor_set_uint8(x_89, 3, x_81);
+lean_ctor_set_uint8(x_89, 4, x_82);
+lean_ctor_set_uint8(x_89, 5, x_88);
+lean_ctor_set_uint8(x_89, 6, x_83);
+lean_ctor_set_uint8(x_89, 7, x_84);
+lean_ctor_set_uint8(x_89, 8, x_85);
+lean_ctor_set_uint8(x_89, 9, x_86);
+x_90 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_90, 0, x_89);
+lean_ctor_set(x_90, 1, x_75);
+lean_ctor_set(x_90, 2, x_76);
+lean_ctor_set(x_90, 3, x_77);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
-lean_inc(x_88);
-x_89 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocessProof(x_2, x_88, x_7, x_8, x_9, x_10);
-if (lean_obj_tag(x_89) == 0)
-{
-lean_object* x_90; lean_object* x_91; lean_object* x_92; size_t x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 
-x_90 = lean_ctor_get(x_89, 0);
 lean_inc(x_90);
-x_91 = lean_ctor_get(x_89, 1);
-lean_inc(x_91);
-lean_dec(x_89);
-x_92 = lean_array_get_size(x_90);
-x_93 = lean_usize_of_nat(x_92);
-lean_dec(x_92);
-x_94 = x_90;
-x_95 = lean_box(x_3);
-x_96 = lean_box_usize(x_93);
-x_97 = l_Lean_Meta_mkSimpLemmas___boxed__const__1;
-x_98 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Meta_mkSimpLemmas___spec__1___boxed), 12, 7);
-lean_closure_set(x_98, 0, x_1);
-lean_closure_set(x_98, 1, x_95);
-lean_closure_set(x_98, 2, x_4);
-lean_closure_set(x_98, 3, x_5);
-lean_closure_set(x_98, 4, x_96);
-lean_closure_set(x_98, 5, x_97);
-lean_closure_set(x_98, 6, x_94);
-x_99 = x_98;
-x_100 = lean_apply_5(x_99, x_88, x_7, x_8, x_9, x_91);
-if (lean_obj_tag(x_100) == 0)
+x_91 = l___private_Lean_Meta_Tactic_Simp_SimpLemmas_0__Lean_Meta_preprocessProof(x_2, x_90, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_91) == 0)
 {
-lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; 
-x_101 = lean_ctor_get(x_100, 0);
-lean_inc(x_101);
-x_102 = lean_ctor_get(x_100, 1);
-lean_inc(x_102);
-if (lean_is_exclusive(x_100)) {
- lean_ctor_release(x_100, 0);
- lean_ctor_release(x_100, 1);
- x_103 = x_100;
+lean_object* x_92; lean_object* x_93; lean_object* x_94; size_t 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; 
+x_92 = lean_ctor_get(x_91, 0);
+lean_inc(x_92);
+x_93 = lean_ctor_get(x_91, 1);
+lean_inc(x_93);
+lean_dec(x_91);
+x_94 = lean_array_get_size(x_92);
+x_95 = lean_usize_of_nat(x_94);
+lean_dec(x_94);
+x_96 = x_92;
+x_97 = lean_box(x_3);
+x_98 = lean_box_usize(x_95);
+x_99 = l_Lean_Meta_mkSimpLemmas___boxed__const__1;
+x_100 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lean_Meta_mkSimpLemmas___spec__1___boxed), 12, 7);
+lean_closure_set(x_100, 0, x_1);
+lean_closure_set(x_100, 1, x_97);
+lean_closure_set(x_100, 2, x_4);
+lean_closure_set(x_100, 3, x_5);
+lean_closure_set(x_100, 4, x_98);
+lean_closure_set(x_100, 5, x_99);
+lean_closure_set(x_100, 6, x_96);
+x_101 = x_100;
+x_102 = lean_apply_5(x_101, x_90, x_7, x_8, x_9, x_93);
+if (lean_obj_tag(x_102) == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; 
+x_103 = lean_ctor_get(x_102, 0);
+lean_inc(x_103);
+x_104 = lean_ctor_get(x_102, 1);
+lean_inc(x_104);
+if (lean_is_exclusive(x_102)) {
+ lean_ctor_release(x_102, 0);
+ lean_ctor_release(x_102, 1);
+ x_105 = x_102;
 } else {
- lean_dec_ref(x_100);
- x_103 = lean_box(0);
+ lean_dec_ref(x_102);
+ x_105 = lean_box(0);
 }
-if (lean_is_scalar(x_103)) {
- x_104 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_105)) {
+ x_106 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_104 = x_103;
+ x_106 = x_105;
 }
-lean_ctor_set(x_104, 0, x_101);
-lean_ctor_set(x_104, 1, x_102);
-return x_104;
+lean_ctor_set(x_106, 0, x_103);
+lean_ctor_set(x_106, 1, x_104);
+return x_106;
 }
 else
 {
-lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
-x_105 = lean_ctor_get(x_100, 0);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_100, 1);
-lean_inc(x_106);
-if (lean_is_exclusive(x_100)) {
- lean_ctor_release(x_100, 0);
- lean_ctor_release(x_100, 1);
- x_107 = x_100;
+lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; 
+x_107 = lean_ctor_get(x_102, 0);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_102, 1);
+lean_inc(x_108);
+if (lean_is_exclusive(x_102)) {
+ lean_ctor_release(x_102, 0);
+ lean_ctor_release(x_102, 1);
+ x_109 = x_102;
 } else {
- lean_dec_ref(x_100);
- x_107 = lean_box(0);
+ lean_dec_ref(x_102);
+ x_109 = lean_box(0);
 }
-if (lean_is_scalar(x_107)) {
- x_108 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_109)) {
+ x_110 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_108 = x_107;
+ x_110 = x_109;
 }
-lean_ctor_set(x_108, 0, x_105);
-lean_ctor_set(x_108, 1, x_106);
-return x_108;
+lean_ctor_set(x_110, 0, x_107);
+lean_ctor_set(x_110, 1, x_108);
+return x_110;
 }
 }
 else
 {
-lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
-lean_dec(x_88);
+lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; 
+lean_dec(x_90);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_1);
-x_109 = lean_ctor_get(x_89, 0);
-lean_inc(x_109);
-x_110 = lean_ctor_get(x_89, 1);
-lean_inc(x_110);
-if (lean_is_exclusive(x_89)) {
- lean_ctor_release(x_89, 0);
- lean_ctor_release(x_89, 1);
- x_111 = x_89;
+x_111 = lean_ctor_get(x_91, 0);
+lean_inc(x_111);
+x_112 = lean_ctor_get(x_91, 1);
+lean_inc(x_112);
+if (lean_is_exclusive(x_91)) {
+ lean_ctor_release(x_91, 0);
+ lean_ctor_release(x_91, 1);
+ x_113 = x_91;
 } else {
- lean_dec_ref(x_89);
- x_111 = lean_box(0);
+ lean_dec_ref(x_91);
+ x_113 = lean_box(0);
 }
-if (lean_is_scalar(x_111)) {
- x_112 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_113)) {
+ x_114 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_112 = x_111;
+ x_114 = x_113;
 }
-lean_ctor_set(x_112, 0, x_109);
-lean_ctor_set(x_112, 1, x_110);
-return x_112;
+lean_ctor_set(x_114, 0, x_111);
+lean_ctor_set(x_114, 1, x_112);
+return x_114;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Util.c b/stage0/stdlib/Lean/Meta/Tactic/Util.c
index c1e80b5814..1a1de62d63 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Util.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Util.c
@@ -15,7 +15,6 @@ extern "C" {
 #endif
 lean_object* l_Lean_ForEachExpr_visit___at_Lean_Meta_getNondepPropHyps_removeDeps___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_getNondepPropHyps___spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* l_Lean_Meta_setMVarTag___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_extractMacroScopes(lean_object*);
 size_t l_USize_add(size_t, size_t);
@@ -38,6 +37,7 @@ lean_object* l_Lean_Meta_checkNotAssigned___closed__3;
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 lean_object* l_Lean_Meta_saturate_go___lambda__1(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_exactlyOne_match__1(lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l_Lean_throwError___at_Lean_Meta_throwTacticEx___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
 lean_object* l_Lean_Meta_checkNotAssigned___closed__1;
@@ -878,7 +878,7 @@ static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Util___hyg_
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l_Lean_Parser_Tactic_intro___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
diff --git a/stage0/stdlib/Lean/Meta/TransparencyMode.c b/stage0/stdlib/Lean/Meta/TransparencyMode.c
index 0bcd381bba..d269a06a5b 100644
--- a/stage0/stdlib/Lean/Meta/TransparencyMode.c
+++ b/stage0/stdlib/Lean/Meta/TransparencyMode.c
@@ -25,7 +25,6 @@ lean_object* l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparenc
 lean_object* l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59____closed__12;
 uint8_t l_Lean_Meta_instInhabitedTransparencyMode;
 lean_object* l_Lean_Meta_TransparencyMode_instHashableTransparencyMode;
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59__match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_TransparencyMode_lt___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59_(uint8_t, lean_object*);
@@ -63,6 +62,7 @@ lean_object* l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparenc
 lean_object* l_Lean_Meta_instBEqTransparencyMode;
 lean_object* l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59____closed__7;
 lean_object* l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59____closed__24;
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Lean_Meta_TransparencyMode_lt_match__1___rarg(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Repr_addAppParen(lean_object*, lean_object*);
 static uint8_t _init_l_Lean_Meta_instInhabitedTransparencyMode() {
@@ -423,7 +423,7 @@ static lean_object* _init_l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_re
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59____closed__2;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -489,7 +489,7 @@ static lean_object* _init_l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_re
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59____closed__8;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -555,7 +555,7 @@ static lean_object* _init_l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_re
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59____closed__14;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -621,7 +621,7 @@ static lean_object* _init_l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_re
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_reprTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_59____closed__20;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
diff --git a/stage0/stdlib/Lean/Meta/UnificationHint.c b/stage0/stdlib/Lean/Meta/UnificationHint.c
index 673ba475cf..a4e8054dac 100644
--- a/stage0/stdlib/Lean/Meta/UnificationHint.c
+++ b/stage0/stdlib/Lean/Meta/UnificationHint.c
@@ -31,7 +31,7 @@ lean_object* l_List_forIn_loop___at_Lean_Meta_tryUnificationHints_tryCandidate__
 lean_object* l_Lean_throwError___at_Lean_Meta_whnf___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_Instances_discrTree___default___closed__1;
 lean_object* l___private_Lean_Meta_UnificationHint_0__Lean_Meta_decodeUnificationHint_decode___closed__1;
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_1634_(lean_object*);
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_1635_(lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_75_(lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_677_(lean_object*);
 extern lean_object* l_Array_back___at___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_insertAux___spec__2___rarg___closed__2;
@@ -153,6 +153,7 @@ lean_object* l___private_Lean_Meta_UnificationHint_0__Lean_Meta_decodeUnificatio
 lean_object* l_List_forM___at___private_Lean_Meta_UnificationHint_0__Lean_Meta_validateHint___spec__1___closed__4;
 lean_object* l_Lean_Meta_instToFormatUnificationHints___boxed(lean_object*);
 lean_object* l_Std_fmt___at_Lean_Meta_addUnificationHint___spec__3(lean_object*);
+extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 lean_object* l_Lean_Meta_instInhabitedUnificationHints;
 lean_object* l_List_forM___at___private_Lean_Meta_UnificationHint_0__Lean_Meta_validateHint___spec__1___closed__1;
 lean_object* l_Std_PersistentHashMap_foldlMAux_traverse___at_Lean_Meta_instToFormatUnificationHints___spec__13___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -163,7 +164,6 @@ lean_object* l_Std_PersistentHashMap_foldlMAux___at_Lean_Meta_instToFormatUnific
 lean_object* l___private_Lean_Meta_UnificationHint_0__Lean_Meta_decodeUnificationHint_decodeConstraint(lean_object*);
 lean_object* l_Lean_Meta_addUnificationHint_match__2___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_addUnificationHint___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
 lean_object* l_Lean_getConstInfo___at_Lean_Meta_mkConstWithFreshMVarLevels___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forM___at___private_Lean_Meta_UnificationHint_0__Lean_Meta_validateHint___spec__1___closed__2;
 lean_object* l___private_Lean_Meta_UnificationHint_0__Lean_Meta_decodeUnificationHint_decode_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -3667,7 +3667,7 @@ lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; uint
 x_48 = lean_ctor_get(x_38, 1);
 lean_inc(x_48);
 lean_dec(x_38);
-x_49 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__4;
+x_49 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__4;
 x_50 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_postponeIsLevelDefEq___spec__2(x_49, x_4, x_5, x_6, x_7, x_48);
 x_51 = lean_ctor_get(x_50, 0);
 lean_inc(x_51);
@@ -4234,7 +4234,7 @@ return x_20;
 }
 else
 {
-uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
+uint8_t x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; 
 x_21 = lean_ctor_get_uint8(x_9, 0);
 x_22 = lean_ctor_get_uint8(x_9, 1);
 x_23 = lean_ctor_get_uint8(x_9, 2);
@@ -4243,164 +4243,168 @@ x_25 = lean_ctor_get_uint8(x_9, 4);
 x_26 = lean_ctor_get_uint8(x_9, 6);
 x_27 = lean_ctor_get_uint8(x_9, 7);
 x_28 = lean_ctor_get_uint8(x_9, 8);
+x_29 = lean_ctor_get_uint8(x_9, 9);
 lean_dec(x_9);
-x_29 = 2;
-x_30 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_30, 0, x_21);
-lean_ctor_set_uint8(x_30, 1, x_22);
-lean_ctor_set_uint8(x_30, 2, x_23);
-lean_ctor_set_uint8(x_30, 3, x_24);
-lean_ctor_set_uint8(x_30, 4, x_25);
-lean_ctor_set_uint8(x_30, 5, x_29);
-lean_ctor_set_uint8(x_30, 6, x_26);
-lean_ctor_set_uint8(x_30, 7, x_27);
-lean_ctor_set_uint8(x_30, 8, x_28);
-lean_ctor_set(x_3, 0, x_30);
-x_31 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_31) == 0)
+x_30 = 2;
+x_31 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_31, 0, x_21);
+lean_ctor_set_uint8(x_31, 1, x_22);
+lean_ctor_set_uint8(x_31, 2, x_23);
+lean_ctor_set_uint8(x_31, 3, x_24);
+lean_ctor_set_uint8(x_31, 4, x_25);
+lean_ctor_set_uint8(x_31, 5, x_30);
+lean_ctor_set_uint8(x_31, 6, x_26);
+lean_ctor_set_uint8(x_31, 7, x_27);
+lean_ctor_set_uint8(x_31, 8, x_28);
+lean_ctor_set_uint8(x_31, 9, x_29);
+lean_ctor_set(x_3, 0, x_31);
+x_32 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_31, 0);
-lean_inc(x_32);
-x_33 = lean_ctor_get(x_31, 1);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_33 = lean_ctor_get(x_32, 0);
 lean_inc(x_33);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_34 = x_31;
+x_34 = lean_ctor_get(x_32, 1);
+lean_inc(x_34);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_35 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_34 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_35 = lean_box(0);
 }
-if (lean_is_scalar(x_34)) {
- x_35 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_35)) {
+ x_36 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_35 = x_34;
+ x_36 = x_35;
 }
-lean_ctor_set(x_35, 0, x_32);
-lean_ctor_set(x_35, 1, x_33);
-return x_35;
+lean_ctor_set(x_36, 0, x_33);
+lean_ctor_set(x_36, 1, x_34);
+return x_36;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_36 = lean_ctor_get(x_31, 0);
-lean_inc(x_36);
-x_37 = lean_ctor_get(x_31, 1);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_37 = lean_ctor_get(x_32, 0);
 lean_inc(x_37);
-if (lean_is_exclusive(x_31)) {
- lean_ctor_release(x_31, 0);
- lean_ctor_release(x_31, 1);
- x_38 = x_31;
+x_38 = lean_ctor_get(x_32, 1);
+lean_inc(x_38);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ lean_ctor_release(x_32, 1);
+ x_39 = x_32;
 } else {
- lean_dec_ref(x_31);
- x_38 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_39 = lean_box(0);
 }
-if (lean_is_scalar(x_38)) {
- x_39 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_39)) {
+ x_40 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_39 = x_38;
+ x_40 = x_39;
 }
-lean_ctor_set(x_39, 0, x_36);
-lean_ctor_set(x_39, 1, x_37);
-return x_39;
+lean_ctor_set(x_40, 0, x_37);
+lean_ctor_set(x_40, 1, x_38);
+return x_40;
 }
 }
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_40 = lean_ctor_get(x_3, 0);
-x_41 = lean_ctor_get(x_3, 1);
-x_42 = lean_ctor_get(x_3, 2);
-x_43 = lean_ctor_get(x_3, 3);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; uint8_t x_48; uint8_t x_49; uint8_t x_50; uint8_t x_51; uint8_t x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_41 = lean_ctor_get(x_3, 0);
+x_42 = lean_ctor_get(x_3, 1);
+x_43 = lean_ctor_get(x_3, 2);
+x_44 = lean_ctor_get(x_3, 3);
+lean_inc(x_44);
 lean_inc(x_43);
 lean_inc(x_42);
 lean_inc(x_41);
-lean_inc(x_40);
 lean_dec(x_3);
-x_44 = lean_ctor_get_uint8(x_40, 0);
-x_45 = lean_ctor_get_uint8(x_40, 1);
-x_46 = lean_ctor_get_uint8(x_40, 2);
-x_47 = lean_ctor_get_uint8(x_40, 3);
-x_48 = lean_ctor_get_uint8(x_40, 4);
-x_49 = lean_ctor_get_uint8(x_40, 6);
-x_50 = lean_ctor_get_uint8(x_40, 7);
-x_51 = lean_ctor_get_uint8(x_40, 8);
-if (lean_is_exclusive(x_40)) {
- x_52 = x_40;
+x_45 = lean_ctor_get_uint8(x_41, 0);
+x_46 = lean_ctor_get_uint8(x_41, 1);
+x_47 = lean_ctor_get_uint8(x_41, 2);
+x_48 = lean_ctor_get_uint8(x_41, 3);
+x_49 = lean_ctor_get_uint8(x_41, 4);
+x_50 = lean_ctor_get_uint8(x_41, 6);
+x_51 = lean_ctor_get_uint8(x_41, 7);
+x_52 = lean_ctor_get_uint8(x_41, 8);
+x_53 = lean_ctor_get_uint8(x_41, 9);
+if (lean_is_exclusive(x_41)) {
+ x_54 = x_41;
 } else {
- lean_dec_ref(x_40);
- x_52 = lean_box(0);
+ lean_dec_ref(x_41);
+ x_54 = lean_box(0);
 }
-x_53 = 2;
-if (lean_is_scalar(x_52)) {
- x_54 = lean_alloc_ctor(0, 0, 9);
+x_55 = 2;
+if (lean_is_scalar(x_54)) {
+ x_56 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_54 = x_52;
+ x_56 = x_54;
 }
-lean_ctor_set_uint8(x_54, 0, x_44);
-lean_ctor_set_uint8(x_54, 1, x_45);
-lean_ctor_set_uint8(x_54, 2, x_46);
-lean_ctor_set_uint8(x_54, 3, x_47);
-lean_ctor_set_uint8(x_54, 4, x_48);
-lean_ctor_set_uint8(x_54, 5, x_53);
-lean_ctor_set_uint8(x_54, 6, x_49);
-lean_ctor_set_uint8(x_54, 7, x_50);
-lean_ctor_set_uint8(x_54, 8, x_51);
-x_55 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_41);
-lean_ctor_set(x_55, 2, x_42);
-lean_ctor_set(x_55, 3, x_43);
-x_56 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_55, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_56) == 0)
+lean_ctor_set_uint8(x_56, 0, x_45);
+lean_ctor_set_uint8(x_56, 1, x_46);
+lean_ctor_set_uint8(x_56, 2, x_47);
+lean_ctor_set_uint8(x_56, 3, x_48);
+lean_ctor_set_uint8(x_56, 4, x_49);
+lean_ctor_set_uint8(x_56, 5, x_55);
+lean_ctor_set_uint8(x_56, 6, x_50);
+lean_ctor_set_uint8(x_56, 7, x_51);
+lean_ctor_set_uint8(x_56, 8, x_52);
+lean_ctor_set_uint8(x_56, 9, x_53);
+x_57 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_57, 0, x_56);
+lean_ctor_set(x_57, 1, x_42);
+lean_ctor_set(x_57, 2, x_43);
+lean_ctor_set(x_57, 3, x_44);
+x_58 = l_Lean_Meta_isExprDefEqAux(x_1, x_2, x_57, x_4, x_5, x_6, 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; 
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_56, 1);
-lean_inc(x_58);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_59 = x_56;
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_59 = lean_ctor_get(x_58, 0);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_58, 1);
+lean_inc(x_60);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_61 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_59 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_61 = lean_box(0);
 }
-if (lean_is_scalar(x_59)) {
- x_60 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_61)) {
+ x_62 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_60 = x_59;
+ x_62 = x_61;
 }
-lean_ctor_set(x_60, 0, x_57);
-lean_ctor_set(x_60, 1, x_58);
-return x_60;
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_60);
+return x_62;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = lean_ctor_get(x_56, 0);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_56, 1);
-lean_inc(x_62);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- lean_ctor_release(x_56, 1);
- x_63 = x_56;
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_63 = lean_ctor_get(x_58, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_58, 1);
+lean_inc(x_64);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ lean_ctor_release(x_58, 1);
+ x_65 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_63 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_65 = lean_box(0);
 }
-if (lean_is_scalar(x_63)) {
- x_64 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_65)) {
+ x_66 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_64 = x_63;
+ x_66 = x_65;
 }
-lean_ctor_set(x_64, 0, x_61);
-lean_ctor_set(x_64, 1, x_62);
-return x_64;
+lean_ctor_set(x_66, 0, x_63);
+lean_ctor_set(x_66, 1, x_64);
+return x_66;
 }
 }
 }
@@ -5882,7 +5886,7 @@ return x_106;
 }
 else
 {
-uint8_t x_107; uint8_t x_108; uint8_t x_109; uint8_t x_110; uint8_t x_111; uint8_t x_112; uint8_t x_113; uint8_t x_114; uint8_t x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; 
+uint8_t x_107; uint8_t x_108; uint8_t x_109; uint8_t x_110; uint8_t x_111; uint8_t x_112; uint8_t x_113; uint8_t x_114; uint8_t x_115; uint8_t x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
 x_107 = lean_ctor_get_uint8(x_77, 0);
 x_108 = lean_ctor_get_uint8(x_77, 1);
 x_109 = lean_ctor_get_uint8(x_77, 2);
@@ -5891,100 +5895,102 @@ x_111 = lean_ctor_get_uint8(x_77, 4);
 x_112 = lean_ctor_get_uint8(x_77, 5);
 x_113 = lean_ctor_get_uint8(x_77, 6);
 x_114 = lean_ctor_get_uint8(x_77, 7);
+x_115 = lean_ctor_get_uint8(x_77, 9);
 lean_dec(x_77);
-x_115 = 0;
-x_116 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_116, 0, x_107);
-lean_ctor_set_uint8(x_116, 1, x_108);
-lean_ctor_set_uint8(x_116, 2, x_109);
-lean_ctor_set_uint8(x_116, 3, x_110);
-lean_ctor_set_uint8(x_116, 4, x_111);
-lean_ctor_set_uint8(x_116, 5, x_112);
-lean_ctor_set_uint8(x_116, 6, x_113);
-lean_ctor_set_uint8(x_116, 7, x_114);
-lean_ctor_set_uint8(x_116, 8, x_115);
-x_117 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_117, 0, x_116);
-lean_ctor_set(x_117, 1, x_79);
-lean_ctor_set(x_117, 2, x_80);
-lean_ctor_set(x_117, 3, x_81);
-x_118 = lean_ctor_get(x_78, 0);
-lean_inc(x_118);
-x_119 = lean_ctor_get(x_118, 0);
+x_116 = 0;
+x_117 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_117, 0, x_107);
+lean_ctor_set_uint8(x_117, 1, x_108);
+lean_ctor_set_uint8(x_117, 2, x_109);
+lean_ctor_set_uint8(x_117, 3, x_110);
+lean_ctor_set_uint8(x_117, 4, x_111);
+lean_ctor_set_uint8(x_117, 5, x_112);
+lean_ctor_set_uint8(x_117, 6, x_113);
+lean_ctor_set_uint8(x_117, 7, x_114);
+lean_ctor_set_uint8(x_117, 8, x_116);
+lean_ctor_set_uint8(x_117, 9, x_115);
+x_118 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_118, 0, x_117);
+lean_ctor_set(x_118, 1, x_79);
+lean_ctor_set(x_118, 2, x_80);
+lean_ctor_set(x_118, 3, x_81);
+x_119 = lean_ctor_get(x_78, 0);
 lean_inc(x_119);
+x_120 = lean_ctor_get(x_119, 0);
+lean_inc(x_120);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
-lean_inc(x_117);
-x_120 = l_Lean_Meta_tryUnificationHints_isDefEqPattern(x_119, x_3, x_117, x_7, x_8, x_9, x_23);
-if (lean_obj_tag(x_120) == 0)
+lean_inc(x_118);
+x_121 = l_Lean_Meta_tryUnificationHints_isDefEqPattern(x_120, x_3, x_118, x_7, x_8, x_9, x_23);
+if (lean_obj_tag(x_121) == 0)
 {
-lean_object* x_121; uint8_t x_122; 
-x_121 = lean_ctor_get(x_120, 0);
-lean_inc(x_121);
-x_122 = lean_unbox(x_121);
-lean_dec(x_121);
-if (x_122 == 0)
+lean_object* x_122; uint8_t x_123; 
+x_122 = lean_ctor_get(x_121, 0);
+lean_inc(x_122);
+x_123 = lean_unbox(x_122);
+lean_dec(x_122);
+if (x_123 == 0)
 {
-lean_object* x_123; 
+lean_object* x_124; 
+lean_dec(x_119);
 lean_dec(x_118);
-lean_dec(x_117);
 lean_dec(x_78);
 lean_dec(x_4);
-x_123 = lean_ctor_get(x_120, 1);
-lean_inc(x_123);
-lean_dec(x_120);
+x_124 = lean_ctor_get(x_121, 1);
+lean_inc(x_124);
+lean_dec(x_121);
 x_28 = x_19;
-x_29 = x_123;
+x_29 = x_124;
 goto block_75;
 }
 else
 {
-lean_object* x_124; lean_object* x_125; lean_object* x_126; 
-x_124 = lean_ctor_get(x_120, 1);
-lean_inc(x_124);
-lean_dec(x_120);
-x_125 = lean_ctor_get(x_118, 1);
+lean_object* x_125; lean_object* x_126; lean_object* x_127; 
+x_125 = lean_ctor_get(x_121, 1);
 lean_inc(x_125);
-lean_dec(x_118);
+lean_dec(x_121);
+x_126 = lean_ctor_get(x_119, 1);
+lean_inc(x_126);
+lean_dec(x_119);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
-x_126 = l_Lean_Meta_tryUnificationHints_isDefEqPattern(x_125, x_4, x_117, x_7, x_8, x_9, x_124);
-if (lean_obj_tag(x_126) == 0)
+x_127 = l_Lean_Meta_tryUnificationHints_isDefEqPattern(x_126, x_4, x_118, x_7, x_8, x_9, x_125);
+if (lean_obj_tag(x_127) == 0)
 {
-lean_object* x_127; uint8_t x_128; 
-x_127 = lean_ctor_get(x_126, 0);
-lean_inc(x_127);
-x_128 = lean_unbox(x_127);
-lean_dec(x_127);
-if (x_128 == 0)
+lean_object* x_128; uint8_t x_129; 
+x_128 = lean_ctor_get(x_127, 0);
+lean_inc(x_128);
+x_129 = lean_unbox(x_128);
+lean_dec(x_128);
+if (x_129 == 0)
 {
-lean_object* x_129; 
+lean_object* x_130; 
 lean_dec(x_78);
-x_129 = lean_ctor_get(x_126, 1);
-lean_inc(x_129);
-lean_dec(x_126);
-x_28 = x_19;
-x_29 = x_129;
-goto block_75;
-}
-else
-{
-lean_object* x_130; lean_object* x_131; 
-x_130 = lean_ctor_get(x_126, 1);
+x_130 = lean_ctor_get(x_127, 1);
 lean_inc(x_130);
-lean_dec(x_126);
-x_131 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_131, 0, x_78);
-x_28 = x_131;
+lean_dec(x_127);
+x_28 = x_19;
 x_29 = x_130;
 goto block_75;
 }
+else
+{
+lean_object* x_131; lean_object* x_132; 
+x_131 = lean_ctor_get(x_127, 1);
+lean_inc(x_131);
+lean_dec(x_127);
+x_132 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_132, 0, x_78);
+x_28 = x_132;
+x_29 = x_131;
+goto block_75;
+}
 }
 else
 {
-lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
+lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
 lean_dec(x_78);
 lean_dec(x_26);
 lean_dec(x_25);
@@ -5995,34 +6001,34 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_2);
 lean_dec(x_1);
-x_132 = lean_ctor_get(x_126, 0);
-lean_inc(x_132);
-x_133 = lean_ctor_get(x_126, 1);
+x_133 = lean_ctor_get(x_127, 0);
 lean_inc(x_133);
-if (lean_is_exclusive(x_126)) {
- lean_ctor_release(x_126, 0);
- lean_ctor_release(x_126, 1);
- x_134 = x_126;
+x_134 = lean_ctor_get(x_127, 1);
+lean_inc(x_134);
+if (lean_is_exclusive(x_127)) {
+ lean_ctor_release(x_127, 0);
+ lean_ctor_release(x_127, 1);
+ x_135 = x_127;
 } else {
- lean_dec_ref(x_126);
- x_134 = lean_box(0);
+ lean_dec_ref(x_127);
+ x_135 = lean_box(0);
 }
-if (lean_is_scalar(x_134)) {
- x_135 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_135)) {
+ x_136 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_135 = x_134;
+ x_136 = x_135;
 }
-lean_ctor_set(x_135, 0, x_132);
-lean_ctor_set(x_135, 1, x_133);
-return x_135;
+lean_ctor_set(x_136, 0, x_133);
+lean_ctor_set(x_136, 1, x_134);
+return x_136;
 }
 }
 }
 else
 {
-lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; 
+lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
+lean_dec(x_119);
 lean_dec(x_118);
-lean_dec(x_117);
 lean_dec(x_78);
 lean_dec(x_26);
 lean_dec(x_25);
@@ -6034,26 +6040,26 @@ lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_136 = lean_ctor_get(x_120, 0);
-lean_inc(x_136);
-x_137 = lean_ctor_get(x_120, 1);
+x_137 = lean_ctor_get(x_121, 0);
 lean_inc(x_137);
-if (lean_is_exclusive(x_120)) {
- lean_ctor_release(x_120, 0);
- lean_ctor_release(x_120, 1);
- x_138 = x_120;
+x_138 = lean_ctor_get(x_121, 1);
+lean_inc(x_138);
+if (lean_is_exclusive(x_121)) {
+ lean_ctor_release(x_121, 0);
+ lean_ctor_release(x_121, 1);
+ x_139 = x_121;
 } else {
- lean_dec_ref(x_120);
- x_138 = lean_box(0);
+ lean_dec_ref(x_121);
+ x_139 = lean_box(0);
 }
-if (lean_is_scalar(x_138)) {
- x_139 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_139)) {
+ x_140 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_139 = x_138;
+ x_140 = x_139;
 }
-lean_ctor_set(x_139, 0, x_136);
-lean_ctor_set(x_139, 1, x_137);
-return x_139;
+lean_ctor_set(x_140, 0, x_137);
+lean_ctor_set(x_140, 1, x_138);
+return x_140;
 }
 }
 }
@@ -6258,7 +6264,7 @@ goto block_53;
 }
 else
 {
-uint8_t x_140; 
+uint8_t x_141; 
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
@@ -6267,23 +6273,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_140 = !lean_is_exclusive(x_11);
-if (x_140 == 0)
+x_141 = !lean_is_exclusive(x_11);
+if (x_141 == 0)
 {
 return x_11;
 }
 else
 {
-lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_141 = lean_ctor_get(x_11, 0);
-x_142 = lean_ctor_get(x_11, 1);
+lean_object* x_142; lean_object* x_143; lean_object* x_144; 
+x_142 = lean_ctor_get(x_11, 0);
+x_143 = lean_ctor_get(x_11, 1);
+lean_inc(x_143);
 lean_inc(x_142);
-lean_inc(x_141);
 lean_dec(x_11);
-x_143 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_143, 0, x_141);
-lean_ctor_set(x_143, 1, x_142);
-return x_143;
+x_144 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_144, 0, x_142);
+lean_ctor_set(x_144, 1, x_143);
+return x_144;
 }
 }
 }
@@ -8221,7 +8227,7 @@ lean_dec(x_3);
 return x_9;
 }
 }
-lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_1634_(lean_object* x_1) {
+lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_1635_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -8347,7 +8353,7 @@ l_Lean_Meta_tryUnificationHints_tryCandidate___closed__3 = _init_l_Lean_Meta_try
 lean_mark_persistent(l_Lean_Meta_tryUnificationHints_tryCandidate___closed__3);
 l_Lean_Meta_tryUnificationHints_tryCandidate___closed__4 = _init_l_Lean_Meta_tryUnificationHints_tryCandidate___closed__4();
 lean_mark_persistent(l_Lean_Meta_tryUnificationHints_tryCandidate___closed__4);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_1634_(lean_io_mk_world());
+res = l_Lean_Meta_initFn____x40_Lean_Meta_UnificationHint___hyg_1635_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));
diff --git a/stage0/stdlib/Lean/Meta/WHNF.c b/stage0/stdlib/Lean/Meta/WHNF.c
index 9e202eca2f..8fb344f092 100644
--- a/stage0/stdlib/Lean/Meta/WHNF.c
+++ b/stage0/stdlib/Lean/Meta/WHNF.c
@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* lean_string_data(lean_object*);
-extern lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
 lean_object* l_Lean_Meta_reduceNative_x3f___closed__1;
 extern lean_object* l_Nat_instDivNat___closed__1;
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_useWHNFCache_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -65,6 +64,7 @@ uint8_t l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_beqTransparencyMode_
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_extractIdRhs(lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_deltaBetaDefinition(lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_reduceQuotRec___rarg(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_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_deltaBetaDefinition___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__2___closed__4;
 lean_object* lean_environment_find(lean_object*, lean_object*);
@@ -81,7 +81,6 @@ lean_object* l_Std_PersistentHashMap_find_x3f___at___private_Lean_Meta_InferType
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_cached_x3f(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_reduceBinNatPred(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_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_getFirstCtor(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isApp(lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_mkNullaryCtor(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -117,6 +116,7 @@ lean_object* l_Lean_Expr_getRevArg_x21(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_reduceNatNative___rarg(lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_deltaDefinition___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_reduceBinNatOp___closed__6;
 extern lean_object* l_Lean_auxRecExt;
@@ -7828,7 +7828,7 @@ static lean_object* _init_l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases_
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1037____closed__2;
+x_1 = l_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1046____closed__2;
 x_2 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__2___closed__4;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
@@ -13104,7 +13104,7 @@ return x_105;
 }
 else
 {
-uint8_t x_106; uint8_t x_107; uint8_t x_108; uint8_t x_109; uint8_t x_110; uint8_t x_111; uint8_t x_112; uint8_t x_113; uint8_t x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
+uint8_t x_106; uint8_t x_107; uint8_t x_108; uint8_t x_109; uint8_t x_110; uint8_t x_111; uint8_t x_112; uint8_t x_113; uint8_t x_114; uint8_t x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
 x_106 = lean_ctor_get_uint8(x_33, 0);
 x_107 = lean_ctor_get_uint8(x_33, 1);
 x_108 = lean_ctor_get_uint8(x_33, 2);
@@ -13113,203 +13113,205 @@ x_110 = lean_ctor_get_uint8(x_33, 4);
 x_111 = lean_ctor_get_uint8(x_33, 6);
 x_112 = lean_ctor_get_uint8(x_33, 7);
 x_113 = lean_ctor_get_uint8(x_33, 8);
+x_114 = lean_ctor_get_uint8(x_33, 9);
 lean_dec(x_33);
-x_114 = 1;
-x_115 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_115, 0, x_106);
-lean_ctor_set_uint8(x_115, 1, x_107);
-lean_ctor_set_uint8(x_115, 2, x_108);
-lean_ctor_set_uint8(x_115, 3, x_109);
-lean_ctor_set_uint8(x_115, 4, x_110);
-lean_ctor_set_uint8(x_115, 5, x_114);
-lean_ctor_set_uint8(x_115, 6, x_111);
-lean_ctor_set_uint8(x_115, 7, x_112);
-lean_ctor_set_uint8(x_115, 8, x_113);
-x_116 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_116, 0, x_115);
-lean_ctor_set(x_116, 1, x_35);
-lean_ctor_set(x_116, 2, x_36);
-lean_ctor_set(x_116, 3, x_37);
+x_115 = 1;
+x_116 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_116, 0, x_106);
+lean_ctor_set_uint8(x_116, 1, x_107);
+lean_ctor_set_uint8(x_116, 2, x_108);
+lean_ctor_set_uint8(x_116, 3, x_109);
+lean_ctor_set_uint8(x_116, 4, x_110);
+lean_ctor_set_uint8(x_116, 5, x_115);
+lean_ctor_set_uint8(x_116, 6, x_111);
+lean_ctor_set_uint8(x_116, 7, x_112);
+lean_ctor_set_uint8(x_116, 8, x_113);
+lean_ctor_set_uint8(x_116, 9, x_114);
+x_117 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_117, 0, x_116);
+lean_ctor_set(x_117, 1, x_35);
+lean_ctor_set(x_117, 2, x_36);
+lean_ctor_set(x_117, 3, x_37);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_117 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_116, x_3, x_4, x_5, x_34);
-if (lean_obj_tag(x_117) == 0)
-{
-lean_object* x_118; 
-x_118 = lean_ctor_get(x_117, 0);
-lean_inc(x_118);
+x_118 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_117, x_3, x_4, x_5, x_34);
 if (lean_obj_tag(x_118) == 0)
 {
-lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; 
+lean_object* x_119; 
+x_119 = lean_ctor_get(x_118, 0);
+lean_inc(x_119);
+if (lean_obj_tag(x_119) == 0)
+{
+lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_119 = lean_ctor_get(x_117, 1);
-lean_inc(x_119);
-if (lean_is_exclusive(x_117)) {
- lean_ctor_release(x_117, 0);
- lean_ctor_release(x_117, 1);
- x_120 = x_117;
+x_120 = lean_ctor_get(x_118, 1);
+lean_inc(x_120);
+if (lean_is_exclusive(x_118)) {
+ lean_ctor_release(x_118, 0);
+ lean_ctor_release(x_118, 1);
+ x_121 = x_118;
 } else {
- lean_dec_ref(x_117);
- x_120 = lean_box(0);
+ lean_dec_ref(x_118);
+ x_121 = lean_box(0);
 }
-x_121 = lean_box(0);
-if (lean_is_scalar(x_120)) {
- x_122 = lean_alloc_ctor(0, 2, 0);
+x_122 = lean_box(0);
+if (lean_is_scalar(x_121)) {
+ x_123 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_122 = x_120;
+ x_123 = x_121;
 }
-lean_ctor_set(x_122, 0, x_121);
-lean_ctor_set(x_122, 1, x_119);
-return x_122;
+lean_ctor_set(x_123, 0, x_122);
+lean_ctor_set(x_123, 1, x_120);
+return x_123;
 }
 else
 {
-lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; 
-x_123 = lean_ctor_get(x_117, 1);
-lean_inc(x_123);
-lean_dec(x_117);
-x_124 = lean_ctor_get(x_118, 0);
+lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; 
+x_124 = lean_ctor_get(x_118, 1);
 lean_inc(x_124);
 lean_dec(x_118);
-x_125 = l_Lean_Expr_getAppFn(x_124);
-x_126 = l_Lean_Meta_reduceProj_x3f(x_125, x_2, x_3, x_4, x_5, x_123);
-if (lean_obj_tag(x_126) == 0)
-{
-lean_object* x_127; 
-x_127 = lean_ctor_get(x_126, 0);
-lean_inc(x_127);
+x_125 = lean_ctor_get(x_119, 0);
+lean_inc(x_125);
+lean_dec(x_119);
+x_126 = l_Lean_Expr_getAppFn(x_125);
+x_127 = l_Lean_Meta_reduceProj_x3f(x_126, x_2, x_3, x_4, x_5, x_124);
 if (lean_obj_tag(x_127) == 0)
 {
-lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; 
-lean_dec(x_124);
-x_128 = lean_ctor_get(x_126, 1);
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_127, 0);
 lean_inc(x_128);
-if (lean_is_exclusive(x_126)) {
- lean_ctor_release(x_126, 0);
- lean_ctor_release(x_126, 1);
- x_129 = x_126;
-} else {
- lean_dec_ref(x_126);
- x_129 = lean_box(0);
-}
-x_130 = lean_box(0);
-if (lean_is_scalar(x_129)) {
- x_131 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_131 = x_129;
-}
-lean_ctor_set(x_131, 0, x_130);
-lean_ctor_set(x_131, 1, x_128);
-return x_131;
-}
-else
+if (lean_obj_tag(x_128) == 0)
 {
-lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; 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; 
-x_132 = lean_ctor_get(x_126, 1);
-lean_inc(x_132);
-if (lean_is_exclusive(x_126)) {
- lean_ctor_release(x_126, 0);
- lean_ctor_release(x_126, 1);
- x_133 = x_126;
-} else {
- lean_dec_ref(x_126);
- x_133 = lean_box(0);
-}
-x_134 = lean_ctor_get(x_127, 0);
-lean_inc(x_134);
+lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; 
+lean_dec(x_125);
+x_129 = lean_ctor_get(x_127, 1);
+lean_inc(x_129);
 if (lean_is_exclusive(x_127)) {
  lean_ctor_release(x_127, 0);
- x_135 = x_127;
+ lean_ctor_release(x_127, 1);
+ x_130 = x_127;
 } else {
  lean_dec_ref(x_127);
- x_135 = lean_box(0);
+ x_130 = lean_box(0);
 }
-x_136 = lean_unsigned_to_nat(0u);
-x_137 = l_Lean_Expr_getAppNumArgsAux(x_124, x_136);
-x_138 = l_Lean_Expr_getAppArgs___closed__1;
-lean_inc(x_137);
-x_139 = lean_mk_array(x_137, x_138);
-x_140 = lean_unsigned_to_nat(1u);
-x_141 = lean_nat_sub(x_137, x_140);
-lean_dec(x_137);
-x_142 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_124, x_139, x_141);
-x_143 = l_Lean_mkAppN(x_134, x_142);
-lean_dec(x_142);
-x_144 = l_Lean_Expr_headBeta(x_143);
-if (lean_is_scalar(x_135)) {
- x_145 = lean_alloc_ctor(1, 1, 0);
+x_131 = lean_box(0);
+if (lean_is_scalar(x_130)) {
+ x_132 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_145 = x_135;
+ x_132 = x_130;
 }
-lean_ctor_set(x_145, 0, x_144);
-if (lean_is_scalar(x_133)) {
- x_146 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_132, 0, x_131);
+lean_ctor_set(x_132, 1, x_129);
+return x_132;
+}
+else
+{
+lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; 
+x_133 = lean_ctor_get(x_127, 1);
+lean_inc(x_133);
+if (lean_is_exclusive(x_127)) {
+ lean_ctor_release(x_127, 0);
+ lean_ctor_release(x_127, 1);
+ x_134 = x_127;
 } else {
- x_146 = x_133;
+ lean_dec_ref(x_127);
+ x_134 = lean_box(0);
+}
+x_135 = lean_ctor_get(x_128, 0);
+lean_inc(x_135);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ x_136 = x_128;
+} else {
+ lean_dec_ref(x_128);
+ x_136 = lean_box(0);
+}
+x_137 = lean_unsigned_to_nat(0u);
+x_138 = l_Lean_Expr_getAppNumArgsAux(x_125, x_137);
+x_139 = l_Lean_Expr_getAppArgs___closed__1;
+lean_inc(x_138);
+x_140 = lean_mk_array(x_138, x_139);
+x_141 = lean_unsigned_to_nat(1u);
+x_142 = lean_nat_sub(x_138, x_141);
+lean_dec(x_138);
+x_143 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_125, x_140, x_142);
+x_144 = l_Lean_mkAppN(x_135, x_143);
+lean_dec(x_143);
+x_145 = l_Lean_Expr_headBeta(x_144);
+if (lean_is_scalar(x_136)) {
+ x_146 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_146 = x_136;
 }
 lean_ctor_set(x_146, 0, x_145);
-lean_ctor_set(x_146, 1, x_132);
-return x_146;
+if (lean_is_scalar(x_134)) {
+ x_147 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_147 = x_134;
+}
+lean_ctor_set(x_147, 0, x_146);
+lean_ctor_set(x_147, 1, x_133);
+return x_147;
 }
 }
 else
 {
-lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; 
-lean_dec(x_124);
-x_147 = lean_ctor_get(x_126, 0);
-lean_inc(x_147);
-x_148 = lean_ctor_get(x_126, 1);
+lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
+lean_dec(x_125);
+x_148 = lean_ctor_get(x_127, 0);
 lean_inc(x_148);
-if (lean_is_exclusive(x_126)) {
- lean_ctor_release(x_126, 0);
- lean_ctor_release(x_126, 1);
- x_149 = x_126;
+x_149 = lean_ctor_get(x_127, 1);
+lean_inc(x_149);
+if (lean_is_exclusive(x_127)) {
+ lean_ctor_release(x_127, 0);
+ lean_ctor_release(x_127, 1);
+ x_150 = x_127;
 } else {
- lean_dec_ref(x_126);
- x_149 = lean_box(0);
+ lean_dec_ref(x_127);
+ x_150 = lean_box(0);
 }
-if (lean_is_scalar(x_149)) {
- x_150 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_150)) {
+ x_151 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_150 = x_149;
+ x_151 = x_150;
 }
-lean_ctor_set(x_150, 0, x_147);
-lean_ctor_set(x_150, 1, x_148);
-return x_150;
+lean_ctor_set(x_151, 0, x_148);
+lean_ctor_set(x_151, 1, x_149);
+return x_151;
 }
 }
 }
 else
 {
-lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; 
+lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_151 = lean_ctor_get(x_117, 0);
-lean_inc(x_151);
-x_152 = lean_ctor_get(x_117, 1);
+x_152 = lean_ctor_get(x_118, 0);
 lean_inc(x_152);
-if (lean_is_exclusive(x_117)) {
- lean_ctor_release(x_117, 0);
- lean_ctor_release(x_117, 1);
- x_153 = x_117;
+x_153 = lean_ctor_get(x_118, 1);
+lean_inc(x_153);
+if (lean_is_exclusive(x_118)) {
+ lean_ctor_release(x_118, 0);
+ lean_ctor_release(x_118, 1);
+ x_154 = x_118;
 } else {
- lean_dec_ref(x_117);
- x_153 = lean_box(0);
+ lean_dec_ref(x_118);
+ x_154 = lean_box(0);
 }
-if (lean_is_scalar(x_153)) {
- x_154 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_154)) {
+ x_155 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_154 = x_153;
+ x_155 = x_154;
 }
-lean_ctor_set(x_154, 0, x_151);
-lean_ctor_set(x_154, 1, x_152);
-return x_154;
+lean_ctor_set(x_155, 0, x_152);
+lean_ctor_set(x_155, 1, x_153);
+return x_155;
 }
 }
 }
@@ -13317,368 +13319,370 @@ return x_154;
 }
 else
 {
-lean_object* x_155; 
+lean_object* x_156; 
 lean_dec(x_15);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_155 = lean_box(0);
-lean_ctor_set(x_7, 0, x_155);
+x_156 = lean_box(0);
+lean_ctor_set(x_7, 0, x_156);
 return x_7;
 }
 }
 }
 else
 {
-lean_object* x_156; lean_object* x_157; uint8_t x_158; uint8_t x_159; uint8_t x_160; 
-x_156 = lean_ctor_get(x_7, 0);
-x_157 = lean_ctor_get(x_7, 1);
+lean_object* x_157; lean_object* x_158; uint8_t x_159; uint8_t x_160; uint8_t x_161; 
+x_157 = lean_ctor_get(x_7, 0);
+x_158 = lean_ctor_get(x_7, 1);
+lean_inc(x_158);
 lean_inc(x_157);
-lean_inc(x_156);
 lean_dec(x_7);
-x_158 = 3;
-x_159 = lean_unbox(x_156);
-lean_dec(x_156);
-x_160 = l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_beqTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_11_(x_159, x_158);
-if (x_160 == 0)
+x_159 = 3;
+x_160 = lean_unbox(x_157);
+lean_dec(x_157);
+x_161 = l___private_Lean_Meta_TransparencyMode_0__Lean_Meta_beqTransparencyMode____x40_Lean_Meta_TransparencyMode___hyg_11_(x_160, x_159);
+if (x_161 == 0)
 {
-lean_object* x_161; lean_object* x_162; 
+lean_object* x_162; lean_object* x_163; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_161 = lean_box(0);
-x_162 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_162, 0, x_161);
-lean_ctor_set(x_162, 1, x_157);
-return x_162;
+x_162 = lean_box(0);
+x_163 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_163, 0, x_162);
+lean_ctor_set(x_163, 1, x_158);
+return x_163;
 }
 else
 {
-lean_object* x_163; 
-x_163 = l_Lean_Expr_getAppFn(x_1);
-if (lean_obj_tag(x_163) == 4)
+lean_object* x_164; 
+x_164 = l_Lean_Expr_getAppFn(x_1);
+if (lean_obj_tag(x_164) == 4)
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; 
-x_164 = lean_ctor_get(x_163, 0);
-lean_inc(x_164);
-lean_dec(x_163);
-x_165 = l_Lean_getProjectionFnInfo_x3f___at___private_Lean_Meta_WHNF_0__Lean_Meta_unfoldProjInst___spec__1(x_164, x_2, x_3, x_4, x_5, x_157);
-x_166 = lean_ctor_get(x_165, 0);
-lean_inc(x_166);
-if (lean_obj_tag(x_166) == 0)
-{
-lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; 
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-x_167 = lean_ctor_get(x_165, 1);
+lean_object* x_165; lean_object* x_166; lean_object* x_167; 
+x_165 = lean_ctor_get(x_164, 0);
+lean_inc(x_165);
+lean_dec(x_164);
+x_166 = l_Lean_getProjectionFnInfo_x3f___at___private_Lean_Meta_WHNF_0__Lean_Meta_unfoldProjInst___spec__1(x_165, x_2, x_3, x_4, x_5, x_158);
+x_167 = lean_ctor_get(x_166, 0);
 lean_inc(x_167);
-if (lean_is_exclusive(x_165)) {
- lean_ctor_release(x_165, 0);
- lean_ctor_release(x_165, 1);
- x_168 = x_165;
-} else {
- lean_dec_ref(x_165);
- x_168 = lean_box(0);
-}
-x_169 = lean_box(0);
-if (lean_is_scalar(x_168)) {
- x_170 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_170 = x_168;
-}
-lean_ctor_set(x_170, 0, x_169);
-lean_ctor_set(x_170, 1, x_167);
-return x_170;
-}
-else
+if (lean_obj_tag(x_167) == 0)
 {
-lean_object* x_171; uint8_t x_172; 
-x_171 = lean_ctor_get(x_166, 0);
-lean_inc(x_171);
-lean_dec(x_166);
-x_172 = lean_ctor_get_uint8(x_171, sizeof(void*)*3);
-lean_dec(x_171);
-if (x_172 == 0)
-{
-lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; 
+lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_173 = lean_ctor_get(x_165, 1);
-lean_inc(x_173);
-if (lean_is_exclusive(x_165)) {
- lean_ctor_release(x_165, 0);
- lean_ctor_release(x_165, 1);
- x_174 = x_165;
+x_168 = lean_ctor_get(x_166, 1);
+lean_inc(x_168);
+if (lean_is_exclusive(x_166)) {
+ lean_ctor_release(x_166, 0);
+ lean_ctor_release(x_166, 1);
+ x_169 = x_166;
 } else {
- lean_dec_ref(x_165);
- x_174 = lean_box(0);
+ lean_dec_ref(x_166);
+ x_169 = lean_box(0);
 }
-x_175 = lean_box(0);
-if (lean_is_scalar(x_174)) {
- x_176 = lean_alloc_ctor(0, 2, 0);
+x_170 = lean_box(0);
+if (lean_is_scalar(x_169)) {
+ x_171 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_176 = x_174;
+ x_171 = x_169;
 }
-lean_ctor_set(x_176, 0, x_175);
-lean_ctor_set(x_176, 1, x_173);
-return x_176;
+lean_ctor_set(x_171, 0, x_170);
+lean_ctor_set(x_171, 1, x_168);
+return x_171;
 }
 else
 {
-lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; uint8_t x_184; uint8_t x_185; uint8_t x_186; uint8_t x_187; uint8_t x_188; uint8_t x_189; lean_object* x_190; uint8_t x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; 
-x_177 = lean_ctor_get(x_2, 0);
-lean_inc(x_177);
-x_178 = lean_ctor_get(x_165, 1);
+lean_object* x_172; uint8_t x_173; 
+x_172 = lean_ctor_get(x_167, 0);
+lean_inc(x_172);
+lean_dec(x_167);
+x_173 = lean_ctor_get_uint8(x_172, sizeof(void*)*3);
+lean_dec(x_172);
+if (x_173 == 0)
+{
+lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_174 = lean_ctor_get(x_166, 1);
+lean_inc(x_174);
+if (lean_is_exclusive(x_166)) {
+ lean_ctor_release(x_166, 0);
+ lean_ctor_release(x_166, 1);
+ x_175 = x_166;
+} else {
+ lean_dec_ref(x_166);
+ x_175 = lean_box(0);
+}
+x_176 = lean_box(0);
+if (lean_is_scalar(x_175)) {
+ x_177 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_177 = x_175;
+}
+lean_ctor_set(x_177, 0, x_176);
+lean_ctor_set(x_177, 1, x_174);
+return x_177;
+}
+else
+{
+lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; uint8_t x_183; uint8_t x_184; uint8_t x_185; uint8_t x_186; uint8_t x_187; uint8_t x_188; uint8_t x_189; uint8_t x_190; uint8_t x_191; lean_object* x_192; uint8_t x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; 
+x_178 = lean_ctor_get(x_2, 0);
 lean_inc(x_178);
-lean_dec(x_165);
-x_179 = lean_ctor_get(x_2, 1);
+x_179 = lean_ctor_get(x_166, 1);
 lean_inc(x_179);
-x_180 = lean_ctor_get(x_2, 2);
+lean_dec(x_166);
+x_180 = lean_ctor_get(x_2, 1);
 lean_inc(x_180);
-x_181 = lean_ctor_get(x_2, 3);
+x_181 = lean_ctor_get(x_2, 2);
 lean_inc(x_181);
-x_182 = lean_ctor_get_uint8(x_177, 0);
-x_183 = lean_ctor_get_uint8(x_177, 1);
-x_184 = lean_ctor_get_uint8(x_177, 2);
-x_185 = lean_ctor_get_uint8(x_177, 3);
-x_186 = lean_ctor_get_uint8(x_177, 4);
-x_187 = lean_ctor_get_uint8(x_177, 6);
-x_188 = lean_ctor_get_uint8(x_177, 7);
-x_189 = lean_ctor_get_uint8(x_177, 8);
-if (lean_is_exclusive(x_177)) {
- x_190 = x_177;
+x_182 = lean_ctor_get(x_2, 3);
+lean_inc(x_182);
+x_183 = lean_ctor_get_uint8(x_178, 0);
+x_184 = lean_ctor_get_uint8(x_178, 1);
+x_185 = lean_ctor_get_uint8(x_178, 2);
+x_186 = lean_ctor_get_uint8(x_178, 3);
+x_187 = lean_ctor_get_uint8(x_178, 4);
+x_188 = lean_ctor_get_uint8(x_178, 6);
+x_189 = lean_ctor_get_uint8(x_178, 7);
+x_190 = lean_ctor_get_uint8(x_178, 8);
+x_191 = lean_ctor_get_uint8(x_178, 9);
+if (lean_is_exclusive(x_178)) {
+ x_192 = x_178;
 } else {
- lean_dec_ref(x_177);
- x_190 = lean_box(0);
+ lean_dec_ref(x_178);
+ x_192 = lean_box(0);
 }
-x_191 = 1;
-if (lean_is_scalar(x_190)) {
- x_192 = lean_alloc_ctor(0, 0, 9);
+x_193 = 1;
+if (lean_is_scalar(x_192)) {
+ x_194 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_192 = x_190;
+ x_194 = x_192;
 }
-lean_ctor_set_uint8(x_192, 0, x_182);
-lean_ctor_set_uint8(x_192, 1, x_183);
-lean_ctor_set_uint8(x_192, 2, x_184);
-lean_ctor_set_uint8(x_192, 3, x_185);
-lean_ctor_set_uint8(x_192, 4, x_186);
-lean_ctor_set_uint8(x_192, 5, x_191);
-lean_ctor_set_uint8(x_192, 6, x_187);
-lean_ctor_set_uint8(x_192, 7, x_188);
-lean_ctor_set_uint8(x_192, 8, x_189);
-x_193 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_193, 0, x_192);
-lean_ctor_set(x_193, 1, x_179);
-lean_ctor_set(x_193, 2, x_180);
-lean_ctor_set(x_193, 3, x_181);
+lean_ctor_set_uint8(x_194, 0, x_183);
+lean_ctor_set_uint8(x_194, 1, x_184);
+lean_ctor_set_uint8(x_194, 2, x_185);
+lean_ctor_set_uint8(x_194, 3, x_186);
+lean_ctor_set_uint8(x_194, 4, x_187);
+lean_ctor_set_uint8(x_194, 5, x_193);
+lean_ctor_set_uint8(x_194, 6, x_188);
+lean_ctor_set_uint8(x_194, 7, x_189);
+lean_ctor_set_uint8(x_194, 8, x_190);
+lean_ctor_set_uint8(x_194, 9, x_191);
+x_195 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_195, 0, x_194);
+lean_ctor_set(x_195, 1, x_180);
+lean_ctor_set(x_195, 2, x_181);
+lean_ctor_set(x_195, 3, x_182);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_194 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_193, x_3, x_4, x_5, x_178);
-if (lean_obj_tag(x_194) == 0)
+x_196 = l_Lean_Meta_unfoldDefinition_x3f(x_1, x_195, x_3, x_4, x_5, x_179);
+if (lean_obj_tag(x_196) == 0)
 {
-lean_object* x_195; 
-x_195 = lean_ctor_get(x_194, 0);
-lean_inc(x_195);
-if (lean_obj_tag(x_195) == 0)
+lean_object* x_197; 
+x_197 = lean_ctor_get(x_196, 0);
+lean_inc(x_197);
+if (lean_obj_tag(x_197) == 0)
 {
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; 
+lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_196 = lean_ctor_get(x_194, 1);
-lean_inc(x_196);
-if (lean_is_exclusive(x_194)) {
- lean_ctor_release(x_194, 0);
- lean_ctor_release(x_194, 1);
- x_197 = x_194;
+x_198 = lean_ctor_get(x_196, 1);
+lean_inc(x_198);
+if (lean_is_exclusive(x_196)) {
+ lean_ctor_release(x_196, 0);
+ lean_ctor_release(x_196, 1);
+ x_199 = x_196;
 } else {
- lean_dec_ref(x_194);
- x_197 = lean_box(0);
+ lean_dec_ref(x_196);
+ x_199 = lean_box(0);
 }
-x_198 = lean_box(0);
-if (lean_is_scalar(x_197)) {
- x_199 = lean_alloc_ctor(0, 2, 0);
+x_200 = lean_box(0);
+if (lean_is_scalar(x_199)) {
+ x_201 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_199 = x_197;
+ x_201 = x_199;
 }
-lean_ctor_set(x_199, 0, x_198);
-lean_ctor_set(x_199, 1, x_196);
-return x_199;
+lean_ctor_set(x_201, 0, x_200);
+lean_ctor_set(x_201, 1, x_198);
+return x_201;
 }
 else
 {
-lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; 
-x_200 = lean_ctor_get(x_194, 1);
-lean_inc(x_200);
-lean_dec(x_194);
-x_201 = lean_ctor_get(x_195, 0);
-lean_inc(x_201);
-lean_dec(x_195);
-x_202 = l_Lean_Expr_getAppFn(x_201);
-x_203 = l_Lean_Meta_reduceProj_x3f(x_202, x_2, x_3, x_4, x_5, x_200);
-if (lean_obj_tag(x_203) == 0)
+lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; 
+x_202 = lean_ctor_get(x_196, 1);
+lean_inc(x_202);
+lean_dec(x_196);
+x_203 = lean_ctor_get(x_197, 0);
+lean_inc(x_203);
+lean_dec(x_197);
+x_204 = l_Lean_Expr_getAppFn(x_203);
+x_205 = l_Lean_Meta_reduceProj_x3f(x_204, x_2, x_3, x_4, x_5, x_202);
+if (lean_obj_tag(x_205) == 0)
 {
-lean_object* x_204; 
-x_204 = lean_ctor_get(x_203, 0);
-lean_inc(x_204);
-if (lean_obj_tag(x_204) == 0)
+lean_object* x_206; 
+x_206 = lean_ctor_get(x_205, 0);
+lean_inc(x_206);
+if (lean_obj_tag(x_206) == 0)
 {
-lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; 
-lean_dec(x_201);
-x_205 = lean_ctor_get(x_203, 1);
-lean_inc(x_205);
-if (lean_is_exclusive(x_203)) {
- lean_ctor_release(x_203, 0);
- lean_ctor_release(x_203, 1);
- x_206 = x_203;
+lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; 
+lean_dec(x_203);
+x_207 = lean_ctor_get(x_205, 1);
+lean_inc(x_207);
+if (lean_is_exclusive(x_205)) {
+ lean_ctor_release(x_205, 0);
+ lean_ctor_release(x_205, 1);
+ x_208 = x_205;
 } else {
- lean_dec_ref(x_203);
- x_206 = lean_box(0);
+ lean_dec_ref(x_205);
+ x_208 = lean_box(0);
 }
-x_207 = lean_box(0);
-if (lean_is_scalar(x_206)) {
- x_208 = lean_alloc_ctor(0, 2, 0);
+x_209 = lean_box(0);
+if (lean_is_scalar(x_208)) {
+ x_210 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_208 = x_206;
+ x_210 = x_208;
 }
-lean_ctor_set(x_208, 0, x_207);
-lean_ctor_set(x_208, 1, x_205);
-return x_208;
+lean_ctor_set(x_210, 0, x_209);
+lean_ctor_set(x_210, 1, x_207);
+return x_210;
 }
 else
 {
-lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; 
-x_209 = lean_ctor_get(x_203, 1);
-lean_inc(x_209);
-if (lean_is_exclusive(x_203)) {
- lean_ctor_release(x_203, 0);
- lean_ctor_release(x_203, 1);
- x_210 = x_203;
-} else {
- lean_dec_ref(x_203);
- x_210 = lean_box(0);
-}
-x_211 = lean_ctor_get(x_204, 0);
+lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; 
+x_211 = lean_ctor_get(x_205, 1);
 lean_inc(x_211);
-if (lean_is_exclusive(x_204)) {
- lean_ctor_release(x_204, 0);
- x_212 = x_204;
+if (lean_is_exclusive(x_205)) {
+ lean_ctor_release(x_205, 0);
+ lean_ctor_release(x_205, 1);
+ x_212 = x_205;
 } else {
- lean_dec_ref(x_204);
+ lean_dec_ref(x_205);
  x_212 = lean_box(0);
 }
-x_213 = lean_unsigned_to_nat(0u);
-x_214 = l_Lean_Expr_getAppNumArgsAux(x_201, x_213);
-x_215 = l_Lean_Expr_getAppArgs___closed__1;
-lean_inc(x_214);
-x_216 = lean_mk_array(x_214, x_215);
-x_217 = lean_unsigned_to_nat(1u);
-x_218 = lean_nat_sub(x_214, x_217);
-lean_dec(x_214);
-x_219 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_201, x_216, x_218);
-x_220 = l_Lean_mkAppN(x_211, x_219);
-lean_dec(x_219);
-x_221 = l_Lean_Expr_headBeta(x_220);
+x_213 = lean_ctor_get(x_206, 0);
+lean_inc(x_213);
+if (lean_is_exclusive(x_206)) {
+ lean_ctor_release(x_206, 0);
+ x_214 = x_206;
+} else {
+ lean_dec_ref(x_206);
+ x_214 = lean_box(0);
+}
+x_215 = lean_unsigned_to_nat(0u);
+x_216 = l_Lean_Expr_getAppNumArgsAux(x_203, x_215);
+x_217 = l_Lean_Expr_getAppArgs___closed__1;
+lean_inc(x_216);
+x_218 = lean_mk_array(x_216, x_217);
+x_219 = lean_unsigned_to_nat(1u);
+x_220 = lean_nat_sub(x_216, x_219);
+lean_dec(x_216);
+x_221 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_203, x_218, x_220);
+x_222 = l_Lean_mkAppN(x_213, x_221);
+lean_dec(x_221);
+x_223 = l_Lean_Expr_headBeta(x_222);
+if (lean_is_scalar(x_214)) {
+ x_224 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_224 = x_214;
+}
+lean_ctor_set(x_224, 0, x_223);
 if (lean_is_scalar(x_212)) {
- x_222 = lean_alloc_ctor(1, 1, 0);
+ x_225 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_222 = x_212;
+ x_225 = x_212;
 }
-lean_ctor_set(x_222, 0, x_221);
-if (lean_is_scalar(x_210)) {
- x_223 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_223 = x_210;
-}
-lean_ctor_set(x_223, 0, x_222);
-lean_ctor_set(x_223, 1, x_209);
-return x_223;
+lean_ctor_set(x_225, 0, x_224);
+lean_ctor_set(x_225, 1, x_211);
+return x_225;
 }
 }
 else
 {
-lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; 
-lean_dec(x_201);
-x_224 = lean_ctor_get(x_203, 0);
-lean_inc(x_224);
-x_225 = lean_ctor_get(x_203, 1);
-lean_inc(x_225);
-if (lean_is_exclusive(x_203)) {
- lean_ctor_release(x_203, 0);
- lean_ctor_release(x_203, 1);
- x_226 = x_203;
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; 
+lean_dec(x_203);
+x_226 = lean_ctor_get(x_205, 0);
+lean_inc(x_226);
+x_227 = lean_ctor_get(x_205, 1);
+lean_inc(x_227);
+if (lean_is_exclusive(x_205)) {
+ lean_ctor_release(x_205, 0);
+ lean_ctor_release(x_205, 1);
+ x_228 = x_205;
 } else {
- lean_dec_ref(x_203);
- x_226 = lean_box(0);
+ lean_dec_ref(x_205);
+ x_228 = lean_box(0);
 }
-if (lean_is_scalar(x_226)) {
- x_227 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_228)) {
+ x_229 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_227 = x_226;
+ x_229 = x_228;
 }
-lean_ctor_set(x_227, 0, x_224);
-lean_ctor_set(x_227, 1, x_225);
-return x_227;
+lean_ctor_set(x_229, 0, x_226);
+lean_ctor_set(x_229, 1, x_227);
+return x_229;
 }
 }
 }
 else
 {
-lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; 
+lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_228 = lean_ctor_get(x_194, 0);
-lean_inc(x_228);
-x_229 = lean_ctor_get(x_194, 1);
-lean_inc(x_229);
-if (lean_is_exclusive(x_194)) {
- lean_ctor_release(x_194, 0);
- lean_ctor_release(x_194, 1);
- x_230 = x_194;
+x_230 = lean_ctor_get(x_196, 0);
+lean_inc(x_230);
+x_231 = lean_ctor_get(x_196, 1);
+lean_inc(x_231);
+if (lean_is_exclusive(x_196)) {
+ lean_ctor_release(x_196, 0);
+ lean_ctor_release(x_196, 1);
+ x_232 = x_196;
 } else {
- lean_dec_ref(x_194);
- x_230 = lean_box(0);
+ lean_dec_ref(x_196);
+ x_232 = lean_box(0);
 }
-if (lean_is_scalar(x_230)) {
- x_231 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_232)) {
+ x_233 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_231 = x_230;
+ x_233 = x_232;
 }
-lean_ctor_set(x_231, 0, x_228);
-lean_ctor_set(x_231, 1, x_229);
-return x_231;
+lean_ctor_set(x_233, 0, x_230);
+lean_ctor_set(x_233, 1, x_231);
+return x_233;
 }
 }
 }
 }
 else
 {
-lean_object* x_232; lean_object* x_233; 
-lean_dec(x_163);
+lean_object* x_234; lean_object* x_235; 
+lean_dec(x_164);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_232 = lean_box(0);
-x_233 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_233, 0, x_232);
-lean_ctor_set(x_233, 1, x_157);
-return x_233;
+x_234 = lean_box(0);
+x_235 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_235, 0, x_234);
+lean_ctor_set(x_235, 1, x_158);
+return x_235;
 }
 }
 }
@@ -13783,7 +13787,7 @@ x_13 = l_Lean_KernelException_toMessageData___closed__15;
 x_14 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_14, 0, x_12);
 lean_ctor_set(x_14, 1, x_13);
-x_15 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_14, x_2, x_3, x_4, x_5, x_9);
+x_15 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_14, x_2, x_3, x_4, x_5, x_9);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
diff --git a/stage0/stdlib/Lean/MonadEnv.c b/stage0/stdlib/Lean/MonadEnv.c
index dc5ca11f4f..d50a9f4110 100644
--- a/stage0/stdlib/Lean/MonadEnv.c
+++ b/stage0/stdlib/Lean/MonadEnv.c
@@ -37,6 +37,7 @@ lean_object* l_List_foldlM___at___private_Lean_MonadEnv_0__Lean_checkUnsupported
 lean_object* l___private_Lean_MonadEnv_0__Lean_supportedRecursors___closed__18;
 lean_object* l_Lean_getConstInfoInduct___rarg___lambda__1___closed__2;
 lean_object* l_Lean_findModuleOf_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_compileDecl_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_findModuleOf_x3f(lean_object*);
 lean_object* l___private_Lean_MonadEnv_0__Lean_supportedRecursors___closed__15;
 lean_object* l_Lean_compileDecl___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -45,7 +46,7 @@ lean_object* l_Lean_mkConstWithLevelParams___rarg(lean_object*, lean_object*, le
 lean_object* l___private_Lean_MonadEnv_0__Lean_checkUnsupported_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldlM___at___private_Lean_MonadEnv_0__Lean_checkUnsupported___spec__2___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfo___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_compileDecl___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_compileDecl___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_MonadEnv_0__Lean_supportedRecursors___closed__6;
 lean_object* lean_environment_find(lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoRec(lean_object*);
@@ -110,7 +111,8 @@ lean_object* l_List_foldlM___at___private_Lean_MonadEnv_0__Lean_checkUnsupported
 lean_object* l_Lean_addDecl___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_MonadEnv_0__Lean_supportedRecursors___closed__16;
 lean_object* l_Lean_mkConstWithLevelParams___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_compileDecl___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_compileDecl___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_compileDecl_match__1(lean_object*);
 lean_object* l_List_foldlM___at___private_Lean_MonadEnv_0__Lean_checkUnsupported___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfo___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoInduct___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3487,12 +3489,65 @@ lean_dec(x_6);
 return x_8;
 }
 }
-lean_object* l_Lean_compileDecl___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* l_Lean_compileDecl_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; 
-x_6 = l_Lean_throwKernelException___rarg(x_1, x_2, x_3, x_4);
-return x_6;
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_2);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+if (lean_obj_tag(x_5) == 11)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+lean_dec(x_5);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_3);
+x_8 = lean_apply_1(x_4, x_5);
+return x_8;
+}
+}
+else
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_apply_1(x_2, x_9);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_compileDecl_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_compileDecl_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_compileDecl___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_5, 0, x_1);
+x_6 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_6, 0, x_5);
+x_7 = l_Lean_throwError___rarg(x_2, x_3, x_6);
+return x_7;
 }
 }
 lean_object* l_Lean_compileDecl___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) {
@@ -3502,34 +3557,50 @@ lean_object* x_9;
 x_9 = lean_compile_decl(x_1, x_8, x_2);
 if (lean_obj_tag(x_9) == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_object* x_10; 
 x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
 lean_dec(x_9);
-lean_inc(x_5);
+if (lean_obj_tag(x_10) == 11)
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+lean_dec(x_5);
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+lean_inc(x_4);
 lean_inc(x_3);
-x_11 = l___private_Lean_MonadEnv_0__Lean_checkUnsupported___rarg(x_3, x_4, x_5, x_2);
-x_12 = lean_alloc_closure((void*)(l_Lean_compileDecl___rarg___lambda__1___boxed), 5, 4);
-lean_closure_set(x_12, 0, x_3);
-lean_closure_set(x_12, 1, x_5);
-lean_closure_set(x_12, 2, x_6);
-lean_closure_set(x_12, 3, x_10);
-x_13 = lean_apply_4(x_7, lean_box(0), lean_box(0), x_11, x_12);
-return x_13;
+x_12 = l___private_Lean_MonadEnv_0__Lean_checkUnsupported___rarg(x_3, x_6, x_4, x_2);
+x_13 = lean_alloc_closure((void*)(l_Lean_compileDecl___rarg___lambda__1___boxed), 4, 3);
+lean_closure_set(x_13, 0, x_11);
+lean_closure_set(x_13, 1, x_3);
+lean_closure_set(x_13, 2, x_4);
+x_14 = lean_apply_4(x_7, lean_box(0), lean_box(0), x_12, x_13);
+return x_14;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; 
+lean_object* x_15; 
 lean_dec(x_7);
 lean_dec(x_6);
+lean_dec(x_2);
+x_15 = l_Lean_throwKernelException___rarg(x_3, x_4, x_5, x_10);
+return x_15;
+}
+}
+else
+{
+lean_object* x_16; lean_object* x_17; 
+lean_dec(x_7);
 lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_14 = lean_ctor_get(x_9, 0);
-lean_inc(x_14);
+x_16 = lean_ctor_get(x_9, 0);
+lean_inc(x_16);
 lean_dec(x_9);
-x_15 = l_Lean_setEnv___rarg(x_4, x_14);
-return x_15;
+x_17 = l_Lean_setEnv___rarg(x_6, x_16);
+return x_17;
 }
 }
 }
@@ -3538,7 +3609,7 @@ _start:
 {
 lean_object* x_8; lean_object* x_9; 
 lean_inc(x_6);
-lean_inc(x_5);
+lean_inc(x_4);
 x_8 = lean_alloc_closure((void*)(l_Lean_compileDecl___rarg___lambda__2___boxed), 8, 7);
 lean_closure_set(x_8, 0, x_7);
 lean_closure_set(x_8, 1, x_1);
@@ -3547,7 +3618,7 @@ lean_closure_set(x_8, 3, x_3);
 lean_closure_set(x_8, 4, x_4);
 lean_closure_set(x_8, 5, x_5);
 lean_closure_set(x_8, 6, x_6);
-x_9 = lean_apply_4(x_6, lean_box(0), lean_box(0), x_5, x_8);
+x_9 = lean_apply_4(x_6, lean_box(0), lean_box(0), x_4, x_8);
 return x_9;
 }
 }
@@ -3563,9 +3634,9 @@ lean_inc(x_6);
 x_8 = lean_alloc_closure((void*)(l_Lean_compileDecl___rarg___lambda__3), 7, 6);
 lean_closure_set(x_8, 0, x_5);
 lean_closure_set(x_8, 1, x_1);
-lean_closure_set(x_8, 2, x_2);
-lean_closure_set(x_8, 3, x_3);
-lean_closure_set(x_8, 4, x_4);
+lean_closure_set(x_8, 2, x_3);
+lean_closure_set(x_8, 3, x_4);
+lean_closure_set(x_8, 4, x_2);
 lean_closure_set(x_8, 5, x_6);
 x_9 = lean_apply_4(x_6, lean_box(0), lean_box(0), x_7, x_8);
 return x_9;
@@ -3579,13 +3650,13 @@ x_2 = lean_alloc_closure((void*)(l_Lean_compileDecl___rarg), 5, 0);
 return x_2;
 }
 }
-lean_object* l_Lean_compileDecl___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_compileDecl___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; 
-x_6 = l_Lean_compileDecl___rarg___lambda__1(x_1, x_2, x_3, x_4, x_5);
-lean_dec(x_5);
-return x_6;
+lean_object* x_5; 
+x_5 = l_Lean_compileDecl___rarg___lambda__1(x_1, x_2, x_3, x_4);
+lean_dec(x_4);
+return x_5;
 }
 }
 lean_object* l_Lean_compileDecl___rarg___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) {
diff --git a/stage0/stdlib/Lean/Parser.c b/stage0/stdlib/Lean/Parser.c
index be83b26fb8..17067167d8 100644
--- a/stage0/stdlib/Lean/Parser.c
+++ b/stage0/stdlib/Lean/Parser.c
@@ -86,6 +86,7 @@ extern lean_object* l_Lean_PrettyPrinter_Formatter_initFn____x40_Lean_PrettyPrin
 lean_object* l_Lean_PrettyPrinter_Formatter_interpretParserDescr___elambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_antiquot_parenthesizer(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Parenthesizer_interpretParserDescr___elambda__6(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__5;
 lean_object* l_Lean_Parser_checkNoWsBefore(lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_928____closed__6;
 extern lean_object* l_termS_x21_____closed__6;
@@ -184,7 +185,6 @@ lean_object* l_Lean_Parser_initFn____x40_Lean_Parser___hyg_4____closed__21;
 lean_object* l_Lean_Parser_initFn____x40_Lean_Parser___hyg_4____closed__38;
 extern lean_object* l_rawNatLit___closed__6;
 lean_object* l_Lean_PrettyPrinter_Formatter_mkAntiquot_formatter___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__6;
 extern lean_object* l_Array_term_____x5b___x3a___x5d___closed__6;
 lean_object* l_Lean_Parser_initFn____x40_Lean_Parser___hyg_4____closed__23;
 lean_object* l_Lean_Parser_initFn____x40_Lean_Parser___hyg_4____closed__13;
@@ -366,7 +366,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_errorAtSavedPos___closed__1;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__6;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__5;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
diff --git a/stage0/stdlib/Lean/Parser/Basic.c b/stage0/stdlib/Lean/Parser/Basic.c
index 08bdcf0a99..5c9a8b2f21 100644
--- a/stage0/stdlib/Lean/Parser/Basic.c
+++ b/stage0/stdlib/Lean/Parser/Basic.c
@@ -309,7 +309,6 @@ lean_object* l_Lean_Parser_scientificLitFn___closed__2;
 lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_instInhabitedParserCategory;
 lean_object* l_Lean_Parser_scientificLitFn___closed__1;
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Parser_setExpectedFn_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_rawIdentFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAntiquotSplice___boxed(lean_object*, lean_object*, lean_object*);
@@ -1076,6 +1075,7 @@ lean_object* l_Lean_Parser_numberFnAux___boxed(lean_object*, lean_object*);
 uint8_t lean_string_dec_lt(lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Syntax_forArgsM___spec__1(lean_object*);
 lean_object* l_Lean_Parser_fieldIdxFn(lean_object*, lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_hexNumberFn___closed__2;
 lean_object* l_Lean_Parser_mkIdent(lean_object*, lean_object*, lean_object*);
@@ -6678,7 +6678,7 @@ if (x_2 == 0)
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_3 = lean_ctor_get(x_1, 1);
-x_4 = l_Int_Int_pow___closed__1;
+x_4 = l_Int_pow___closed__1;
 x_5 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_5, 0, x_4);
 lean_closure_set(x_5, 1, x_3);
@@ -6693,7 +6693,7 @@ x_7 = lean_ctor_get(x_1, 1);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_dec(x_1);
-x_8 = l_Int_Int_pow___closed__1;
+x_8 = l_Int_pow___closed__1;
 x_9 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_9, 0, x_8);
 lean_closure_set(x_9, 1, x_7);
@@ -6708,7 +6708,7 @@ static lean_object* _init_l_Lean_Parser_decQuotDepth___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = lean_int_neg(x_1);
 return x_2;
 }
diff --git a/stage0/stdlib/Lean/Parser/Command.c b/stage0/stdlib/Lean/Parser/Command.c
index c9b2289884..c936a976dc 100644
--- a/stage0/stdlib/Lean/Parser/Command.c
+++ b/stage0/stdlib/Lean/Parser/Command.c
@@ -983,7 +983,6 @@ lean_object* l_Lean_Parser_Command_attribute_formatter___closed__2;
 lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__13;
 lean_object* l_Lean_Parser_Command_classInductive_parenthesizer___closed__4;
 lean_object* l_Lean_Parser_Command_structSimpleBinder___closed__3;
-extern lean_object* l_Int_Int_pow___closed__1;
 extern lean_object* l_Lean_Parser_Term_forall_parenthesizer___closed__3;
 lean_object* l_Lean_Parser_Command_end_parenthesizer___closed__3;
 lean_object* l_Lean_Parser_Command_axiom_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3450,6 +3449,7 @@ lean_object* l_Lean_Parser_Command_resolve__name_parenthesizer___closed__3;
 lean_object* l_Lean_Parser_Command_universes_formatter___closed__2;
 lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__12;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_synth(lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Lean_Parser_Command_classTk_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_abbrev_parenthesizer___closed__8;
 lean_object* l_Lean_Parser_Command_initialize_parenthesizer___closed__8;
@@ -3585,7 +3585,7 @@ static lean_object* _init_l_Lean_Parser_Term_quot___elambda__1___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_quot___elambda__1___closed__7;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -3759,7 +3759,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_quot___elambda__1___closed__7;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
diff --git a/stage0/stdlib/Lean/Parser/Do.c b/stage0/stdlib/Lean/Parser/Do.c
index a126ef4fae..f964b83b6f 100644
--- a/stage0/stdlib/Lean/Parser/Do.c
+++ b/stage0/stdlib/Lean/Parser/Do.c
@@ -542,7 +542,6 @@ lean_object* l_Lean_Parser_Term_doIf_formatter___closed__19;
 lean_object* l_Lean_Parser_Term_doIf___closed__5;
 lean_object* l_Lean_Parser_Term_doHave___elambda__1___closed__10;
 lean_object* l___regBuiltin_Lean_Parser_Term_doLetRec_parenthesizer(lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Parser_Term_doContinue_formatter___closed__3;
 extern lean_object* l_Lean_Parser_Term_assert___closed__2;
 lean_object* l_Lean_Parser_Term_doReassignArrow___elambda__1(lean_object*, lean_object*);
@@ -671,6 +670,7 @@ lean_object* l_Lean_Parser_Term_doFor_parenthesizer___closed__7;
 lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doReturn___elambda__1___closed__15;
 lean_object* l_Lean_Parser_symbolFn___boxed(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_doReassign___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_doDbgTrace___elambda__1___closed__15;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_doUnless(lean_object*);
@@ -1610,7 +1610,6 @@ lean_object* l_Lean_Parser_Term_leftArrow___closed__1;
 lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__39;
 lean_object* l_Lean_Parser_Term_do___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_doLet___elambda__1___closed__2;
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__6;
 lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Term_doNested___closed__3;
 lean_object* l_Lean_Parser_Term_doUnless___elambda__1___closed__21;
@@ -1892,6 +1891,7 @@ lean_object* l_Lean_Parser_Term_doReassign_parenthesizer___closed__1;
 lean_object* l_Lean_Parser_Term_doIf___closed__11;
 lean_object* l_Lean_Parser_Term_termTry___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_doPatDecl___closed__8;
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Lean_Parser_Term_do_parenthesizer___closed__2;
 lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__17;
 lean_object* l_Lean_Parser_Term_doIfLetBind_parenthesizer___closed__1;
@@ -7474,7 +7474,7 @@ static lean_object* _init_l_Lean_Parser_Term_doPatDecl___elambda__1___closed__15
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__6;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__5;
 x_2 = l_Lean_Parser_Term_doPatDecl___elambda__1___closed__13;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -27610,7 +27610,7 @@ static lean_object* _init_l_Lean_Parser_Term_doElem_quot___elambda__1___closed__
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_doSeqItem___elambda__1___closed__9;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -27841,7 +27841,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_doSeqItem___elambda__1___closed__9;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
diff --git a/stage0/stdlib/Lean/Parser/Module.c b/stage0/stdlib/Lean/Parser/Module.c
index 2cd7f067c7..793211866d 100644
--- a/stage0/stdlib/Lean/Parser/Module.c
+++ b/stage0/stdlib/Lean/Parser/Module.c
@@ -173,7 +173,6 @@ lean_object* l_Lean_Parser_Module_module___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Module_import_parenthesizer___closed__2;
 lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__11;
 lean_object* l_Lean_Syntax_updateLeading(lean_object*);
-lean_object* lean_io_realpath(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_header___closed__8;
 lean_object* l___private_Lean_Parser_Module_0__Lean_Parser_mkErrorMessage___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_module___elambda__1___closed__4;
@@ -5276,159 +5275,125 @@ return x_7;
 lean_object* l_Lean_Parser_testParseModule(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_5; 
-x_5 = lean_io_realpath(x_2, x_4);
-if (lean_obj_tag(x_5) == 0)
+lean_object* x_5; lean_object* x_6; 
+x_5 = l_Lean_Parser_mkInputContext(x_3, x_2);
+lean_inc(x_5);
+x_6 = l_Lean_Parser_parseHeader(x_5, x_4);
+if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_ctor_get(x_5, 1);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_7 = lean_ctor_get(x_6, 0);
 lean_inc(x_7);
-lean_dec(x_5);
-x_8 = l_Lean_Parser_mkInputContext(x_3, x_6);
+x_8 = lean_ctor_get(x_7, 1);
 lean_inc(x_8);
-x_9 = l_Lean_Parser_parseHeader(x_8, x_7);
-if (lean_obj_tag(x_9) == 0)
-{
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_10 = lean_ctor_get(x_9, 0);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+lean_dec(x_6);
+x_10 = lean_ctor_get(x_7, 0);
 lean_inc(x_10);
-x_11 = lean_ctor_get(x_10, 1);
+lean_dec(x_7);
+x_11 = lean_ctor_get(x_8, 0);
 lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 1);
+x_12 = lean_ctor_get(x_8, 1);
 lean_inc(x_12);
-lean_dec(x_9);
-x_13 = lean_ctor_get(x_10, 0);
-lean_inc(x_13);
-lean_dec(x_10);
-x_14 = lean_ctor_get(x_11, 0);
-lean_inc(x_14);
-x_15 = lean_ctor_get(x_11, 1);
-lean_inc(x_15);
-lean_dec(x_11);
-x_16 = l_Array_empty___closed__1;
-x_17 = l_Lean_Parser_testParseModuleAux_parse(x_1, x_8, x_14, x_15, x_16, x_12);
-if (lean_obj_tag(x_17) == 0)
-{
-uint8_t x_18; 
-x_18 = !lean_is_exclusive(x_17);
-if (x_18 == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_19 = lean_ctor_get(x_17, 0);
-x_20 = l_Lean_nullKind;
-x_21 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_21, 0, x_20);
-lean_ctor_set(x_21, 1, x_19);
-x_22 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
-x_23 = lean_array_push(x_22, x_13);
-x_24 = lean_array_push(x_23, x_21);
-x_25 = l_Lean_Parser_Module_module_formatter___closed__2;
-x_26 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_24);
-x_27 = l_Lean_Syntax_updateLeading(x_26);
-lean_ctor_set(x_17, 0, x_27);
-return x_17;
-}
-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; lean_object* x_37; lean_object* x_38; 
-x_28 = lean_ctor_get(x_17, 0);
-x_29 = lean_ctor_get(x_17, 1);
-lean_inc(x_29);
-lean_inc(x_28);
-lean_dec(x_17);
-x_30 = l_Lean_nullKind;
-x_31 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_31, 0, x_30);
-lean_ctor_set(x_31, 1, x_28);
-x_32 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
-x_33 = lean_array_push(x_32, x_13);
-x_34 = lean_array_push(x_33, x_31);
-x_35 = l_Lean_Parser_Module_module_formatter___closed__2;
-x_36 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_36, 0, x_35);
-lean_ctor_set(x_36, 1, x_34);
-x_37 = l_Lean_Syntax_updateLeading(x_36);
-x_38 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_38, 0, x_37);
-lean_ctor_set(x_38, 1, x_29);
-return x_38;
-}
-}
-else
-{
-uint8_t x_39; 
-lean_dec(x_13);
-x_39 = !lean_is_exclusive(x_17);
-if (x_39 == 0)
-{
-return x_17;
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_40 = lean_ctor_get(x_17, 0);
-x_41 = lean_ctor_get(x_17, 1);
-lean_inc(x_41);
-lean_inc(x_40);
-lean_dec(x_17);
-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;
-}
-}
-}
-else
-{
-uint8_t x_43; 
 lean_dec(x_8);
-lean_dec(x_1);
-x_43 = !lean_is_exclusive(x_9);
-if (x_43 == 0)
+x_13 = l_Array_empty___closed__1;
+x_14 = l_Lean_Parser_testParseModuleAux_parse(x_1, x_5, x_11, x_12, x_13, x_9);
+if (lean_obj_tag(x_14) == 0)
 {
-return x_9;
+uint8_t x_15; 
+x_15 = !lean_is_exclusive(x_14);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_16 = lean_ctor_get(x_14, 0);
+x_17 = l_Lean_nullKind;
+x_18 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_18, 0, x_17);
+lean_ctor_set(x_18, 1, x_16);
+x_19 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
+x_20 = lean_array_push(x_19, x_10);
+x_21 = lean_array_push(x_20, x_18);
+x_22 = l_Lean_Parser_Module_module_formatter___closed__2;
+x_23 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_23, 0, x_22);
+lean_ctor_set(x_23, 1, x_21);
+x_24 = l_Lean_Syntax_updateLeading(x_23);
+lean_ctor_set(x_14, 0, x_24);
+return x_14;
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_44 = lean_ctor_get(x_9, 0);
-x_45 = lean_ctor_get(x_9, 1);
-lean_inc(x_45);
-lean_inc(x_44);
-lean_dec(x_9);
-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;
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_25 = lean_ctor_get(x_14, 0);
+x_26 = lean_ctor_get(x_14, 1);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_dec(x_14);
+x_27 = l_Lean_nullKind;
+x_28 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_28, 0, x_27);
+lean_ctor_set(x_28, 1, x_25);
+x_29 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
+x_30 = lean_array_push(x_29, x_10);
+x_31 = lean_array_push(x_30, x_28);
+x_32 = l_Lean_Parser_Module_module_formatter___closed__2;
+x_33 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_33, 0, x_32);
+lean_ctor_set(x_33, 1, x_31);
+x_34 = l_Lean_Syntax_updateLeading(x_33);
+x_35 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_35, 0, x_34);
+lean_ctor_set(x_35, 1, x_26);
+return x_35;
+}
+}
+else
+{
+uint8_t x_36; 
+lean_dec(x_10);
+x_36 = !lean_is_exclusive(x_14);
+if (x_36 == 0)
+{
+return x_14;
+}
+else
+{
+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_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_47; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_47 = !lean_is_exclusive(x_5);
-if (x_47 == 0)
-{
-return x_5;
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-x_48 = lean_ctor_get(x_5, 0);
-x_49 = lean_ctor_get(x_5, 1);
-lean_inc(x_49);
-lean_inc(x_48);
+uint8_t x_40; 
 lean_dec(x_5);
-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;
+lean_dec(x_1);
+x_40 = !lean_is_exclusive(x_6);
+if (x_40 == 0)
+{
+return x_6;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_41 = lean_ctor_get(x_6, 0);
+x_42 = lean_ctor_get(x_6, 1);
+lean_inc(x_42);
+lean_inc(x_41);
+lean_dec(x_6);
+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;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Parser/Syntax.c b/stage0/stdlib/Lean/Parser/Syntax.c
index f2d10bc01c..5dbf65a521 100644
--- a/stage0/stdlib/Lean/Parser/Syntax.c
+++ b/stage0/stdlib/Lean/Parser/Syntax.c
@@ -496,7 +496,6 @@ lean_object* l_Lean_Parser_Command_elab_formatter___closed__13;
 lean_object* l_Lean_Parser_Command_elab;
 lean_object* l_Lean_Parser_Command_elab___closed__7;
 lean_object* l_Lean_Parser_Command_identPrec___closed__5;
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Parser_Syntax_sepBy___closed__9;
 lean_object* l_Lean_Parser_Term_prio_quot_parenthesizer___closed__5;
 lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1___closed__6;
@@ -1771,6 +1770,7 @@ lean_object* l_Lean_Parser_Command_macroArgSymbol___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Syntax_nonReserved___elambda__1___closed__11;
 lean_object* l___regBuiltin_Lean_Parser_Term_prec_quot_parenthesizer___closed__1;
 lean_object* l___regBuiltin_Lean_Parser_Command_mixfix_parenthesizer(lean_object*);
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l___regBuiltin_Lean_Parser_Command_macro_formatter___closed__1;
 lean_object* l_Lean_Parser_Command_elab_formatter___closed__14;
 lean_object* l_Lean_Parser_Command_notationItem_formatter(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -7885,7 +7885,7 @@ static lean_object* _init_l_Lean_Parser_Term_stx_quot___elambda__1___closed__6()
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_stx_quot___elambda__1___closed__5;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -8116,7 +8116,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_stx_quot___elambda__1___closed__5;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -8558,7 +8558,7 @@ static lean_object* _init_l_Lean_Parser_Term_prec_quot___elambda__1___closed__6(
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_prec_quot___elambda__1___closed__5;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -8789,7 +8789,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_prec_quot___elambda__1___closed__5;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -9239,7 +9239,7 @@ static lean_object* _init_l_Lean_Parser_Term_prio_quot___elambda__1___closed__5(
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Attr_simple___elambda__1___closed__5;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -9470,7 +9470,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Attr_simple___elambda__1___closed__5;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -19447,7 +19447,7 @@ static lean_object* _init_l_Lean_Parser_Command_macroTailCommand___elambda__1___
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_quot___elambda__1___closed__6;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -19620,7 +19620,7 @@ static lean_object* _init_l_Lean_Parser_Command_macroTailDefault___elambda__1___
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Command_macroTailDefault___elambda__1___closed__1;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
diff --git a/stage0/stdlib/Lean/Parser/Term.c b/stage0/stdlib/Lean/Parser/Term.c
index 2481a0606d..e545bc6679 100644
--- a/stage0/stdlib/Lean/Parser/Term.c
+++ b/stage0/stdlib/Lean/Parser/Term.c
@@ -113,6 +113,7 @@ lean_object* l_Lean_Parser_Term_macroLastArg_formatter___closed__2;
 lean_object* l___regBuiltin_Lean_Parser_Term_pipeCompletion_parenthesizer___closed__1;
 lean_object* l_Lean_Parser_Term_trueVal_parenthesizer___closed__1;
 lean_object* l___regBuiltin_Lean_Parser_Term_forall_parenthesizer___closed__1;
+extern lean_object* l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9;
 lean_object* l_Lean_Parser_Term_have_parenthesizer___closed__7;
 lean_object* l_Lean_Parser_Term_byTactic_formatter___closed__4;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__10;
@@ -1300,7 +1301,6 @@ lean_object* l_Lean_Parser_Term_nomatch___closed__4;
 lean_object* l_Lean_Parser_Term_whereDecls___closed__2;
 lean_object* l_Lean_Parser_Term_hole___closed__6;
 lean_object* l_Lean_Parser_Term_letRecDecls_formatter(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l_Lean_Parser_Term_forall_parenthesizer___closed__3;
 lean_object* l_Lean_Parser_Tactic_quot_parenthesizer___closed__2;
 lean_object* l_Lean_Parser_Term_simpleBinderWithoutType___closed__4;
@@ -1957,7 +1957,6 @@ lean_object* l_Lean_Parser_Term_falseVal_parenthesizer___closed__2;
 lean_object* l_Lean_Parser_Term_stateRefT___closed__2;
 lean_object* l_Lean_Parser_Term_pipeProj___closed__5;
 lean_object* l_Lean_Parser_Tactic_quotSeq_parenthesizer___closed__2;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_Parser_Term_structInstLVal___elambda__1___closed__18;
 lean_object* l_Lean_Parser_Term_letRecDecl_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doubleQuotedName___closed__5;
@@ -2526,6 +2525,7 @@ lean_object* l_Lean_Parser_Term_dbgTrace_formatter___closed__4;
 lean_object* l_Lean_Parser_initFn____x40_Lean_Parser_Term___hyg_58____closed__4;
 lean_object* l_Lean_Parser_Term_optEllipsis___closed__5;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__8;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_Parser_Term_leading__parser___closed__8;
 lean_object* l_Lean_Parser_Tactic_quotSeq_formatter___closed__3;
 lean_object* l_Lean_Parser_Term_pipeCompletion___closed__3;
@@ -2742,6 +2742,7 @@ lean_object* l_Lean_Parser_Term_letEqnsDecl_formatter___closed__1;
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_funSimpleBinder_formatter___closed__2;
 lean_object* l_Lean_Parser_Term_whereDecls___elambda__1___closed__9;
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 lean_object* l_Lean_Parser_Term_matchAltsWhereDecls___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_fun___closed__8;
 lean_object* l_Lean_Parser_Term_attrInstance;
@@ -3111,7 +3112,6 @@ lean_object* l_Lean_Parser_Level_quot___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_explicitUniv_parenthesizer___closed__3;
 lean_object* l_Lean_Parser_Term_let__fun_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
 extern lean_object* l_Lean_PrettyPrinter_Formatter_formatterAliasesRef;
 lean_object* l_Lean_Parser_Term_attrKind;
 lean_object* l_Lean_Parser_Term_sorry;
@@ -4652,7 +4652,6 @@ lean_object* l_Lean_Parser_Term_noindex_formatter___closed__2;
 extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15852____closed__1;
 lean_object* l_Lean_Parser_Term_leading__parser___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_let;
-lean_object* l_Lean_Parser_Term_type___elambda__1___closed__25;
 extern lean_object* l_Lean_Parser_identNoAntiquot___closed__2;
 lean_object* l___regBuiltin_Lean_Parser_Tactic_quotSeq_parenthesizer___closed__1;
 lean_object* l_Lean_Parser_Term_bracketedBinder___boxed(lean_object*);
@@ -4696,6 +4695,7 @@ lean_object* l_Lean_Parser_Term_cdot_formatter___closed__3;
 lean_object* l_Lean_Parser_Term_cdot_parenthesizer___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_binop(lean_object*);
 lean_object* l_Lean_Parser_Term_matchDiscr_quot___closed__5;
+extern lean_object* l_Int_pow___closed__1;
 lean_object* l_Lean_Parser_Term_arrayRef___closed__3;
 lean_object* l_Lean_Parser_Tactic_quot___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__8;
@@ -8645,43 +8645,35 @@ return x_5;
 static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__1() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_mk_string("type");
-return x_1;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_myMacro____x40_Init_Notation___hyg_1997____closed__2;
+x_2 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
 }
 }
 static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__2() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Notation___hyg_1997____closed__2;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__1;
-x_3 = lean_name_mk_string(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__3() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_2 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__4() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__3;
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__2;
 x_3 = 1;
 x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__5() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -8689,17 +8681,17 @@ x_1 = lean_mk_string("checkColGt");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__6() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__5;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__4;
 x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkColGtFn___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__7() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
@@ -8711,11 +8703,11 @@ x_4 = l_Lean_Parser_andthenInfo(x_3, x_2);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__8() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__6;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__5;
 x_2 = l_Lean_Parser_Level_max___elambda__1___closed__8;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -8723,39 +8715,39 @@ lean_closure_set(x_3, 1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__9() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_epsilonInfo;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__7;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__6;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
 }
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__9() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_byTactic___elambda__1___closed__8;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__7;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
+return x_3;
+}
+}
 static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_byTactic___elambda__1___closed__8;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__8;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
-lean_closure_set(x_3, 0, x_1);
-lean_closure_set(x_3, 1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__11() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_epsilonInfo;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__9;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__8;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__12() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__11() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -8765,40 +8757,40 @@ lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__13() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__12;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__10;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__11;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__9;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__14() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__11;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__13;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__10;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__12;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__15() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__14;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__13;
 x_2 = l_Lean_Parser_optional(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__16() {
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__15() {
 _start:
 {
 lean_object* x_1; 
@@ -8806,12 +8798,22 @@ x_1 = lean_mk_string("Type");
 return x_1;
 }
 }
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__16() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__15;
+x_2 = l_String_trim(x_1);
+return x_2;
+}
+}
 static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__17() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_type___elambda__1___closed__16;
-x_2 = l_String_trim(x_1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
+lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
@@ -8820,7 +8822,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_type___elambda__1___closed__17;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_tokenWithAntiquotFn), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
@@ -8828,34 +8830,36 @@ return x_2;
 static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__19() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__18;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_tokenWithAntiquotFn), 3, 1);
-lean_closure_set(x_2, 0, x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__20() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__15;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__14;
 x_2 = lean_ctor_get(x_1, 1);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__19;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__18;
 x_4 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_4, 0, x_3);
 lean_closure_set(x_4, 1, x_2);
 return x_4;
 }
 }
+static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__20() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__19;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
+return x_3;
+}
+}
 static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__21() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__20;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__20;
+x_2 = l_Lean_Parser_Level_paren___elambda__1___closed__12;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
@@ -8865,8 +8869,8 @@ static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__22() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__21;
-x_2 = l_Lean_Parser_Level_paren___elambda__1___closed__12;
+x_1 = l_Lean_Parser_Level_paren___elambda__1___closed__10;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__21;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
@@ -8877,11 +8881,9 @@ static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__23() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Level_paren___elambda__1___closed__10;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__22;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
-lean_closure_set(x_3, 0, x_1);
-lean_closure_set(x_3, 1, x_2);
+x_1 = l_Char_quote___closed__1;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
@@ -8889,17 +8891,7 @@ static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__24() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Char_quote___closed__1;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__17;
-x_3 = lean_string_append(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__25() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__24;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__23;
 x_2 = l_Char_quote___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
@@ -8909,10 +8901,10 @@ lean_object* l_Lean_Parser_Term_type___elambda__1(lean_object* x_1, lean_object*
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__15;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__14;
 x_4 = lean_ctor_get(x_3, 1);
 lean_inc(x_4);
-x_5 = l_Lean_Parser_Term_type___elambda__1___closed__4;
+x_5 = l_Lean_Parser_Term_type___elambda__1___closed__3;
 x_6 = lean_ctor_get(x_5, 1);
 lean_inc(x_6);
 lean_inc(x_2);
@@ -8942,8 +8934,8 @@ x_13 = lean_ctor_get(x_9, 0);
 lean_inc(x_13);
 x_14 = lean_array_get_size(x_13);
 lean_dec(x_13);
-x_15 = l_Lean_Parser_Term_type___elambda__1___closed__17;
-x_16 = l_Lean_Parser_Term_type___elambda__1___closed__25;
+x_15 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_16 = l_Lean_Parser_Term_type___elambda__1___closed__24;
 lean_inc(x_1);
 x_17 = l_Lean_Parser_symbolFnAux(x_15, x_16, x_1, x_9);
 x_18 = lean_ctor_get(x_17, 4);
@@ -8989,7 +8981,7 @@ if (x_22 == 0)
 {
 lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
 lean_dec(x_4);
-x_23 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_23 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_24 = l_Lean_Parser_ParserState_mkNode(x_20, x_23, x_14);
 x_25 = lean_ctor_get(x_24, 4);
 lean_inc(x_25);
@@ -9013,7 +9005,7 @@ else
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
 lean_inc(x_1);
 x_28 = lean_apply_2(x_4, x_1, x_20);
-x_29 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_29 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_14);
 x_31 = lean_ctor_get(x_30, 4);
 lean_inc(x_31);
@@ -9039,7 +9031,7 @@ else
 {
 lean_object* x_40; uint8_t x_41; lean_object* x_42; 
 lean_dec(x_4);
-x_40 = l_Lean_Parser_Term_type___elambda__1___closed__23;
+x_40 = l_Lean_Parser_Term_type___elambda__1___closed__22;
 x_41 = 1;
 x_42 = l_Lean_Parser_orelseFnCore(x_6, x_40, x_41, x_1, x_2);
 return x_42;
@@ -9050,7 +9042,7 @@ static lean_object* _init_l_Lean_Parser_Term_type___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__17;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__16;
 x_2 = l_Lean_Parser_symbolInfo(x_1);
 return x_2;
 }
@@ -9059,7 +9051,7 @@ static lean_object* _init_l_Lean_Parser_Term_type___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__15;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__14;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_type___closed__1;
@@ -9071,7 +9063,7 @@ static lean_object* _init_l_Lean_Parser_Term_type___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_2 = l_Lean_Parser_Term_type___closed__2;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
@@ -9101,7 +9093,7 @@ static lean_object* _init_l_Lean_Parser_Term_type___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__4;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__3;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_type___closed__5;
@@ -9142,7 +9134,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_2 = l_term___u2218_____closed__6;
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_4 = 1;
 x_5 = l_Lean_Parser_Term_type;
 x_6 = lean_unsigned_to_nat(1000u);
@@ -9154,8 +9146,8 @@ static lean_object* _init_l_Lean_Parser_Term_type_formatter___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__3;
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__2;
 x_3 = 1;
 x_4 = lean_box(x_3);
 x_5 = lean_alloc_closure((void*)(l_Lean_Parser_mkAntiquot_formatter___boxed), 8, 3);
@@ -9169,7 +9161,7 @@ static lean_object* _init_l_Lean_Parser_Term_type_formatter___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbol_formatter), 6, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
@@ -9237,7 +9229,7 @@ static lean_object* _init_l_Lean_Parser_Term_type_formatter___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_2 = lean_unsigned_to_nat(1024u);
 x_3 = l_Lean_Parser_Term_type_formatter___closed__7;
 x_4 = lean_alloc_closure((void*)(l_Lean_Parser_leadingNode_formatter___boxed), 8, 3);
@@ -9270,7 +9262,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_2 = l_Lean_PrettyPrinter_formatterAttribute;
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_4 = l___regBuiltin_Lean_Parser_Term_type_formatter___closed__1;
 x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1);
 return x_5;
@@ -9280,8 +9272,8 @@ static lean_object* _init_l_Lean_Parser_Term_type_parenthesizer___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__3;
+x_1 = l___private_Init_System_IO_0__IO_FS_reprMetadata____x40_Init_System_IO___hyg_2280____closed__9;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__2;
 x_3 = 1;
 x_4 = lean_box(x_3);
 x_5 = lean_alloc_closure((void*)(l_Lean_Parser_mkAntiquot_parenthesizer___boxed), 8, 3);
@@ -9295,7 +9287,7 @@ static lean_object* _init_l_Lean_Parser_Term_type_parenthesizer___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbol_parenthesizer), 6, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
@@ -9373,7 +9365,7 @@ static lean_object* _init_l_Lean_Parser_Term_type_parenthesizer___closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_2 = lean_unsigned_to_nat(1024u);
 x_3 = l_Lean_Parser_Term_type_parenthesizer___closed__8;
 x_4 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_Parenthesizer_leadingNode_parenthesizer___boxed), 8, 3);
@@ -9406,7 +9398,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_2 = l_Lean_PrettyPrinter_parenthesizerAttribute;
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_4 = l___regBuiltin_Lean_Parser_Term_type_parenthesizer___closed__1;
 x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1);
 return x_5;
@@ -9466,7 +9458,7 @@ static lean_object* _init_l_Lean_Parser_Term_sort___elambda__1___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__15;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__14;
 x_2 = lean_ctor_get(x_1, 1);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_sort___elambda__1___closed__5;
@@ -9536,7 +9528,7 @@ lean_object* l_Lean_Parser_Term_sort___elambda__1(lean_object* x_1, lean_object*
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__15;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__14;
 x_4 = lean_ctor_get(x_3, 1);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
@@ -9686,7 +9678,7 @@ static lean_object* _init_l_Lean_Parser_Term_sort___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_type___elambda__1___closed__15;
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__14;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_sort___closed__1;
@@ -22791,7 +22783,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec___elambda__1___closed__1()
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_2, 0, x_1);
 return x_2;
@@ -22801,7 +22793,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec___elambda__1___closed__2()
 _start:
 {
 lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_2 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__1;
 x_3 = 1;
 x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
@@ -22812,7 +22804,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec___elambda__1___closed__3()
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__6;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -22923,7 +22915,7 @@ lean_dec(x_19);
 if (x_20 == 0)
 {
 lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
-x_21 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_21 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_22 = l_Lean_Parser_ParserState_mkNode(x_18, x_21, x_12);
 x_23 = lean_ctor_get(x_22, 4);
 lean_inc(x_23);
@@ -22949,7 +22941,7 @@ x_26 = l_term___u2218_____closed__6;
 x_27 = lean_unsigned_to_nat(0u);
 lean_inc(x_1);
 x_28 = l_Lean_Parser_categoryParser___elambda__1(x_26, x_27, x_1, x_18);
-x_29 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_29 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_12);
 x_31 = lean_ctor_get(x_30, 4);
 lean_inc(x_31);
@@ -22985,7 +22977,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2 = l_Lean_Parser_Term_typeAscription___closed__2;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
@@ -28424,7 +28416,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec_formatter___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_2 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__1;
 x_3 = 1;
 x_4 = lean_box(x_3);
@@ -28439,7 +28431,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec_formatter___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2 = lean_unsigned_to_nat(1024u);
 x_3 = l_Lean_Parser_Term_typeAscription_formatter___closed__3;
 x_4 = lean_alloc_closure((void*)(l_Lean_Parser_leadingNode_formatter___boxed), 8, 3);
@@ -28698,7 +28690,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec_parenthesizer___closed__1(
 _start:
 {
 lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__6;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__4;
 x_2 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__1;
 x_3 = 1;
 x_4 = lean_box(x_3);
@@ -28713,7 +28705,7 @@ static lean_object* _init_l_Lean_Parser_Term_typeSpec_parenthesizer___closed__2(
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_1 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_2 = lean_unsigned_to_nat(1024u);
 x_3 = l_Lean_Parser_Term_typeAscription_parenthesizer___closed__3;
 x_4 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_Parenthesizer_leadingNode_parenthesizer___boxed), 8, 3);
@@ -61947,7 +61939,7 @@ static lean_object* _init_l_Lean_Parser_Term_funBinder_quot___elambda__1___close
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_funBinder_quot___elambda__1___closed__6;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -62178,7 +62170,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_funBinder_quot___elambda__1___closed__6;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -62666,7 +62658,7 @@ static lean_object* _init_l_Lean_Parser_Term_bracketedBinder_quot___elambda__1__
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_bracketedBinder_quot___elambda__1___closed__7;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -62897,7 +62889,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_bracketedBinder_quot___elambda__1___closed__7;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -63349,7 +63341,7 @@ static lean_object* _init_l_Lean_Parser_Term_matchDiscr_quot___elambda__1___clos
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_matchDiscr_quot___elambda__1___closed__4;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -63580,7 +63572,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_matchDiscr_quot___elambda__1___closed__4;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -64030,7 +64022,7 @@ static lean_object* _init_l_Lean_Parser_Term_attr_quot___elambda__1___closed__5(
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_attrInstance___elambda__1___closed__3;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -64261,7 +64253,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Term_attrInstance___elambda__1___closed__3;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -69906,7 +69898,7 @@ static lean_object* _init_l_Lean_Parser_Term_dynamicQuot___elambda__1___closed__
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Term_dynamicQuot___elambda__1___closed__3;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -70275,7 +70267,7 @@ goto block_24;
 else
 {
 lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; 
-x_39 = l_Int_Int_pow___closed__1;
+x_39 = l_Int_pow___closed__1;
 x_40 = l_Lean_Parser_Term_dynamicQuot___elambda__1___closed__3;
 lean_inc(x_1);
 x_41 = l_Lean_Parser_addQuotDepthFn(x_39, x_40, x_1, x_36);
@@ -70831,7 +70823,7 @@ static lean_object* _init_l_Lean_Parser_Tactic_quot___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Tactic_tacticSeq1Indented___elambda__1___closed__11;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -71062,7 +71054,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Tactic_tacticSeq1Indented___elambda__1___closed__11;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -71490,7 +71482,7 @@ static lean_object* _init_l_Lean_Parser_Tactic_quotSeq___elambda__1___closed__5(
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Tactic_seq1___closed__2;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -71664,7 +71656,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Tactic_seq1___closed__2;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -72145,7 +72137,7 @@ static lean_object* _init_l_Lean_Parser_Level_quot___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l_Lean_Parser_Level_paren___elambda__1___closed__5;
 x_3 = lean_alloc_closure((void*)(l_Lean_Parser_addQuotDepthFn___boxed), 4, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -72376,7 +72368,7 @@ goto block_24;
 else
 {
 lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = l_Int_Int_pow___closed__1;
+x_28 = l_Int_pow___closed__1;
 x_29 = l_Lean_Parser_Level_paren___elambda__1___closed__5;
 lean_inc(x_1);
 x_30 = l_Lean_Parser_addQuotDepthFn(x_28, x_29, x_1, x_25);
@@ -74446,8 +74438,6 @@ l_Lean_Parser_Term_type___elambda__1___closed__23 = _init_l_Lean_Parser_Term_typ
 lean_mark_persistent(l_Lean_Parser_Term_type___elambda__1___closed__23);
 l_Lean_Parser_Term_type___elambda__1___closed__24 = _init_l_Lean_Parser_Term_type___elambda__1___closed__24();
 lean_mark_persistent(l_Lean_Parser_Term_type___elambda__1___closed__24);
-l_Lean_Parser_Term_type___elambda__1___closed__25 = _init_l_Lean_Parser_Term_type___elambda__1___closed__25();
-lean_mark_persistent(l_Lean_Parser_Term_type___elambda__1___closed__25);
 l_Lean_Parser_Term_type___closed__1 = _init_l_Lean_Parser_Term_type___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_type___closed__1);
 l_Lean_Parser_Term_type___closed__2 = _init_l_Lean_Parser_Term_type___closed__2();
diff --git a/stage0/stdlib/Lean/ParserCompiler.c b/stage0/stdlib/Lean/ParserCompiler.c
index 6137530aad..d4ec1cb70f 100644
--- a/stage0/stdlib/Lean/ParserCompiler.c
+++ b/stage0/stdlib/Lean/ParserCompiler.c
@@ -80,7 +80,6 @@ lean_object* l_Lean_ParserCompiler_registerParserCompiler___rarg___lambda__1___c
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l_Lean_ParserCompiler_Context_tyName___rarg(lean_object*);
 lean_object* l_Lean_ParserCompiler_CombinatorAttribute_getDeclFor_x3f(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldrMUnsafe_fold___at_Lean_ParserCompiler_compileParserExpr___spec__7___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ParserCompiler_registerParserCompiler___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__29(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*);
@@ -112,6 +111,7 @@ lean_object* l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__44___boxed
 lean_object* l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__18(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_ParserCompiler_compileParserExpr___spec__9___at_Lean_ParserCompiler_compileParserExpr___spec__10___rarg(lean_object*, 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_object* l_Std_Range_forIn_loop___at_Lean_ParserCompiler_compileParserExpr___spec__14(lean_object*);
+lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_ParserCompiler_compileParserExpr___spec__3___rarg(lean_object*, 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_object*);
 lean_object* l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__51(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldrMUnsafe_fold___at_Lean_ParserCompiler_compileParserExpr___spec__42(lean_object*);
@@ -20606,7 +20606,7 @@ x_80 = l_Lean_KernelException_toMessageData___closed__3;
 x_81 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_81, 0, x_79);
 lean_ctor_set(x_81, 1, x_80);
-x_82 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_81, x_4, x_5, x_6, x_7, x_72);
+x_82 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_81, x_4, x_5, x_6, x_7, x_72);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -20710,7 +20710,7 @@ x_46 = l_Lean_KernelException_toMessageData___closed__3;
 x_47 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_47, 0, x_45);
 lean_ctor_set(x_47, 1, x_46);
-x_48 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_47, x_4, x_5, x_6, x_7, x_36);
+x_48 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_47, x_4, x_5, x_6, x_7, x_36);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -20945,7 +20945,7 @@ x_116 = l_Lean_KernelException_toMessageData___closed__3;
 x_117 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_117, 0, x_115);
 lean_ctor_set(x_117, 1, x_116);
-x_118 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_117, x_4, x_5, x_6, x_7, x_11);
+x_118 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_117, x_4, x_5, x_6, x_7, x_11);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -21104,7 +21104,7 @@ x_192 = l_Lean_KernelException_toMessageData___closed__3;
 x_193 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_193, 0, x_191);
 lean_ctor_set(x_193, 1, x_192);
-x_194 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_193, x_4, x_5, x_6, x_7, x_184);
+x_194 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_193, x_4, x_5, x_6, x_7, x_184);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -21208,7 +21208,7 @@ x_158 = l_Lean_KernelException_toMessageData___closed__3;
 x_159 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_159, 0, x_157);
 lean_ctor_set(x_159, 1, x_158);
-x_160 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_159, x_4, x_5, x_6, x_7, x_148);
+x_160 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_159, x_4, x_5, x_6, x_7, x_148);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -21443,7 +21443,7 @@ x_228 = l_Lean_KernelException_toMessageData___closed__3;
 x_229 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_229, 0, x_227);
 lean_ctor_set(x_229, 1, x_228);
-x_230 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_229, x_4, x_5, x_6, x_7, x_123);
+x_230 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_229, x_4, x_5, x_6, x_7, x_123);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -21574,7 +21574,7 @@ x_300 = l_Lean_KernelException_toMessageData___closed__3;
 x_301 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_301, 0, x_299);
 lean_ctor_set(x_301, 1, x_300);
-x_302 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_301, x_4, x_5, x_6, x_7, x_292);
+x_302 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_301, x_4, x_5, x_6, x_7, x_292);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -21678,7 +21678,7 @@ x_266 = l_Lean_KernelException_toMessageData___closed__3;
 x_267 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_267, 0, x_265);
 lean_ctor_set(x_267, 1, x_266);
-x_268 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_267, x_4, x_5, x_6, x_7, x_256);
+x_268 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_267, x_4, x_5, x_6, x_7, x_256);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -21913,7 +21913,7 @@ x_336 = l_Lean_KernelException_toMessageData___closed__3;
 x_337 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_337, 0, x_335);
 lean_ctor_set(x_337, 1, x_336);
-x_338 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_337, x_4, x_5, x_6, x_7, x_231);
+x_338 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_337, x_4, x_5, x_6, x_7, x_231);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -22044,7 +22044,7 @@ x_408 = l_Lean_KernelException_toMessageData___closed__3;
 x_409 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_409, 0, x_407);
 lean_ctor_set(x_409, 1, x_408);
-x_410 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_409, x_4, x_5, x_6, x_7, x_400);
+x_410 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_409, x_4, x_5, x_6, x_7, x_400);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -22148,7 +22148,7 @@ x_374 = l_Lean_KernelException_toMessageData___closed__3;
 x_375 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_375, 0, x_373);
 lean_ctor_set(x_375, 1, x_374);
-x_376 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_375, x_4, x_5, x_6, x_7, x_364);
+x_376 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_375, x_4, x_5, x_6, x_7, x_364);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -22383,7 +22383,7 @@ x_444 = l_Lean_KernelException_toMessageData___closed__3;
 x_445 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_445, 0, x_443);
 lean_ctor_set(x_445, 1, x_444);
-x_446 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_445, x_4, x_5, x_6, x_7, x_339);
+x_446 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_445, x_4, x_5, x_6, x_7, x_339);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -22514,7 +22514,7 @@ x_516 = l_Lean_KernelException_toMessageData___closed__3;
 x_517 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_517, 0, x_515);
 lean_ctor_set(x_517, 1, x_516);
-x_518 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_517, x_4, x_5, x_6, x_7, x_508);
+x_518 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_517, x_4, x_5, x_6, x_7, x_508);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -22618,7 +22618,7 @@ x_482 = l_Lean_KernelException_toMessageData___closed__3;
 x_483 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_483, 0, x_481);
 lean_ctor_set(x_483, 1, x_482);
-x_484 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_483, x_4, x_5, x_6, x_7, x_472);
+x_484 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_483, x_4, x_5, x_6, x_7, x_472);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -22853,7 +22853,7 @@ x_552 = l_Lean_KernelException_toMessageData___closed__3;
 x_553 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_553, 0, x_551);
 lean_ctor_set(x_553, 1, x_552);
-x_554 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_553, x_4, x_5, x_6, x_7, x_447);
+x_554 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_553, x_4, x_5, x_6, x_7, x_447);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -22997,7 +22997,7 @@ x_628 = l_Lean_KernelException_toMessageData___closed__3;
 x_629 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_629, 0, x_627);
 lean_ctor_set(x_629, 1, x_628);
-x_630 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_629, x_4, x_5, x_6, x_7, x_620);
+x_630 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_629, x_4, x_5, x_6, x_7, x_620);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -23101,7 +23101,7 @@ x_594 = l_Lean_KernelException_toMessageData___closed__3;
 x_595 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_595, 0, x_593);
 lean_ctor_set(x_595, 1, x_594);
-x_596 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_595, x_4, x_5, x_6, x_7, x_584);
+x_596 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_595, x_4, x_5, x_6, x_7, x_584);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -23336,7 +23336,7 @@ x_664 = l_Lean_KernelException_toMessageData___closed__3;
 x_665 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_665, 0, x_663);
 lean_ctor_set(x_665, 1, x_664);
-x_666 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_665, x_4, x_5, x_6, x_7, x_559);
+x_666 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_665, x_4, x_5, x_6, x_7, x_559);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -23467,7 +23467,7 @@ x_736 = l_Lean_KernelException_toMessageData___closed__3;
 x_737 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_737, 0, x_735);
 lean_ctor_set(x_737, 1, x_736);
-x_738 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_737, x_4, x_5, x_6, x_7, x_728);
+x_738 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_737, x_4, x_5, x_6, x_7, x_728);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -23571,7 +23571,7 @@ x_702 = l_Lean_KernelException_toMessageData___closed__3;
 x_703 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_703, 0, x_701);
 lean_ctor_set(x_703, 1, x_702);
-x_704 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_703, x_4, x_5, x_6, x_7, x_692);
+x_704 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_703, x_4, x_5, x_6, x_7, x_692);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -23806,7 +23806,7 @@ x_772 = l_Lean_KernelException_toMessageData___closed__3;
 x_773 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_773, 0, x_771);
 lean_ctor_set(x_773, 1, x_772);
-x_774 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_773, x_4, x_5, x_6, x_7, x_667);
+x_774 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_773, x_4, x_5, x_6, x_7, x_667);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -23937,7 +23937,7 @@ x_844 = l_Lean_KernelException_toMessageData___closed__3;
 x_845 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_845, 0, x_843);
 lean_ctor_set(x_845, 1, x_844);
-x_846 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_845, x_4, x_5, x_6, x_7, x_836);
+x_846 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_845, x_4, x_5, x_6, x_7, x_836);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -24041,7 +24041,7 @@ x_810 = l_Lean_KernelException_toMessageData___closed__3;
 x_811 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_811, 0, x_809);
 lean_ctor_set(x_811, 1, x_810);
-x_812 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_811, x_4, x_5, x_6, x_7, x_800);
+x_812 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_811, x_4, x_5, x_6, x_7, x_800);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -24276,7 +24276,7 @@ x_880 = l_Lean_KernelException_toMessageData___closed__3;
 x_881 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_881, 0, x_879);
 lean_ctor_set(x_881, 1, x_880);
-x_882 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_881, x_4, x_5, x_6, x_7, x_775);
+x_882 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_881, x_4, x_5, x_6, x_7, x_775);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -24407,7 +24407,7 @@ x_952 = l_Lean_KernelException_toMessageData___closed__3;
 x_953 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_953, 0, x_951);
 lean_ctor_set(x_953, 1, x_952);
-x_954 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_953, x_4, x_5, x_6, x_7, x_944);
+x_954 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_953, x_4, x_5, x_6, x_7, x_944);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -24511,7 +24511,7 @@ x_918 = l_Lean_KernelException_toMessageData___closed__3;
 x_919 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_919, 0, x_917);
 lean_ctor_set(x_919, 1, x_918);
-x_920 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_919, x_4, x_5, x_6, x_7, x_908);
+x_920 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_919, x_4, x_5, x_6, x_7, x_908);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -24746,7 +24746,7 @@ x_988 = l_Lean_KernelException_toMessageData___closed__3;
 x_989 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_989, 0, x_987);
 lean_ctor_set(x_989, 1, x_988);
-x_990 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_989, x_4, x_5, x_6, x_7, x_883);
+x_990 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_989, x_4, x_5, x_6, x_7, x_883);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -24877,7 +24877,7 @@ x_1060 = l_Lean_KernelException_toMessageData___closed__3;
 x_1061 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_1061, 0, x_1059);
 lean_ctor_set(x_1061, 1, x_1060);
-x_1062 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_1061, x_4, x_5, x_6, x_7, x_1052);
+x_1062 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_1061, x_4, x_5, x_6, x_7, x_1052);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -24981,7 +24981,7 @@ x_1026 = l_Lean_KernelException_toMessageData___closed__3;
 x_1027 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_1027, 0, x_1025);
 lean_ctor_set(x_1027, 1, x_1026);
-x_1028 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_1027, x_4, x_5, x_6, x_7, x_1016);
+x_1028 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_1027, x_4, x_5, x_6, x_7, x_1016);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -25216,7 +25216,7 @@ x_1096 = l_Lean_KernelException_toMessageData___closed__3;
 x_1097 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_1097, 0, x_1095);
 lean_ctor_set(x_1097, 1, x_1096);
-x_1098 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1612____spec__1(x_1097, x_4, x_5, x_6, x_7, x_991);
+x_1098 = l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_1621____spec__1(x_1097, x_4, x_5, x_6, x_7, x_991);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
diff --git a/stage0/stdlib/Lean/ParserCompiler/Attribute.c b/stage0/stdlib/Lean/ParserCompiler/Attribute.c
index 7b5fd08fcc..d3938e4aa8 100644
--- a/stage0/stdlib/Lean/ParserCompiler/Attribute.c
+++ b/stage0/stdlib/Lean/ParserCompiler/Attribute.c
@@ -62,7 +62,7 @@ lean_object* lean_eval_const(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_persistentEnvExtensionsRef;
 lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_0__Lean_sanitizeSyntaxAux___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*);
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 extern lean_object* l_Lean_KernelException_toMessageData___closed__3;
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
@@ -559,7 +559,7 @@ _start:
 lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_4 = l_Lean_mkMapDeclarationExtension___rarg___closed__1;
 x_5 = l_Lean_ParserCompiler_registerCombinatorAttribute___closed__1;
-x_6 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_6 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_inc(x_1);
 x_7 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_7, 0, x_1);
diff --git a/stage0/stdlib/Lean/PrettyPrinter.c b/stage0/stdlib/Lean/PrettyPrinter.c
index b4516e9709..963f241ebd 100644
--- a/stage0/stdlib/Lean/PrettyPrinter.c
+++ b/stage0/stdlib/Lean/PrettyPrinter.c
@@ -14,11 +14,13 @@
 extern "C" {
 #endif
 lean_object* l_Lean_sanitizeSyntax(lean_object*, lean_object*);
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__3___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__3(lean_object*, lean_object*, lean_object*);
 size_t l_USize_add(size_t, size_t);
 lean_object* lean_io_get_num_heartbeats(lean_object*);
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
 lean_object* l_Lean_PPContext_runMetaM___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__3(lean_object*, lean_object*, lean_object*);
+lean_object* lean_name_mk_string(lean_object*, lean_object*);
 extern lean_object* l_Lean_InternalExceptionId_toString___closed__1;
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Lean_PrettyPrinter_formatTerm(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -34,36 +36,37 @@ lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_parenthesizeCommand(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_noContext_match__1(lean_object*);
 lean_object* l_ReaderT_bind___at_Lean_Meta_instMonadLCtxMetaM___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_parenthesizeTerm(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_noContext___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_instInhabitedCache___closed__1;
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__2;
 lean_object* l_Lean_PrettyPrinter_ppExpr___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_PrettyPrinter_parenthesizerAttribute;
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__2;
 extern lean_object* l_Lean_PrettyPrinter_Formatter_categoryParser_formatter___lambda__2___closed__4;
 extern lean_object* l_Lean_PrettyPrinter_mkFormatterAttribute___closed__4;
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__3;
 lean_object* l_Lean_MessageData_toString(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_ppModule(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__3;
 lean_object* l_Lean_PPContext_runMetaM___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_ppExpr___closed__1;
 lean_object* l_Lean_PrettyPrinter_ppCommand(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PPContext_runCoreM___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_ppTerm(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_377_(lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338_(lean_object*);
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_380_(lean_object*);
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341_(lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 lean_object* l_Lean_PrettyPrinter_registerParserCompilers___closed__2;
 extern lean_object* l_Lean_ppFnsRef;
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* l_Lean_Core_getMaxHeartbeats(lean_object*);
 lean_object* l_Lean_PrettyPrinter_parenthesize(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__1;
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__4;
 lean_object* lean_pp_expr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__4;
 extern lean_object* l_Lean_PrettyPrinter_combinatorFormatterAttribute;
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__1;
 lean_object* l_Lean_PrettyPrinter_registerParserCompilers___closed__1;
 lean_object* l_Lean_PrettyPrinter_ppExpr___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_PrettyPrinter_formatterAttribute;
@@ -74,10 +77,12 @@ size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_PrettyPrinter_format(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_NameSet_empty;
 lean_object* l_Lean_PPContext_runCoreM___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext_match__1(lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_PPContext_runCoreM___rarg___closed__2;
 lean_object* l_Lean_PrettyPrinter_delab(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_PPContext_runCoreM___rarg___closed__1;
 lean_object* l_Lean_PrettyPrinter_formatCommand(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_ppModule___closed__2;
 extern lean_object* l_Lean_resetTraceState___rarg___lambda__1___closed__1;
@@ -86,24 +91,53 @@ extern lean_object* l_Lean_PrettyPrinter_combinatorParenthesizerAttribute;
 lean_object* l_Lean_PrettyPrinter_ppModule___closed__1;
 extern lean_object* l_Lean_PrettyPrinter_mkParenthesizerAttribute___closed__4;
 lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___rarg___lambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_PPContext_runCoreM___rarg___closed__3;
 lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext(lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_module_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_Context_config___default___closed__1;
 lean_object* l_Lean_Meta_ppGoal___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ParserCompiler_registerParserCompiler___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__2(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLCtx___at_Lean_Meta_ppGoal___spec__15___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_noContext___spec__1(size_t, size_t, lean_object*);
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_noContext_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Core_State_ngen___default___closed__1;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PPContext_runMetaM(lean_object*);
+lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalContext_sanitizeNames(lean_object*, lean_object*);
+static lean_object* _init_l_Lean_PPContext_runCoreM___rarg___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("_pp_uniq");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_PPContext_runCoreM___rarg___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Lean_PPContext_runCoreM___rarg___closed__1;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l_Lean_PPContext_runCoreM___rarg___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_PPContext_runCoreM___rarg___closed__2;
+x_2 = lean_unsigned_to_nat(1u);
+x_3 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
 lean_object* l_Lean_PPContext_runCoreM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -114,7 +148,7 @@ x_6 = lean_ctor_get(x_1, 4);
 x_7 = lean_ctor_get(x_1, 5);
 x_8 = l_Lean_Core_getMaxHeartbeats(x_5);
 x_9 = l_Lean_Unhygienic_run___rarg___closed__2;
-x_10 = l_Lean_Core_State_ngen___default___closed__1;
+x_10 = l_Lean_PPContext_runCoreM___rarg___closed__3;
 x_11 = l_Lean_resetTraceState___rarg___lambda__1___closed__1;
 lean_inc(x_4);
 x_12 = lean_alloc_ctor(0, 4, 0);
@@ -1348,7 +1382,7 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_0__Lean_PrettyPr
 return x_2;
 }
 }
-lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
@@ -1454,7 +1488,7 @@ return x_28;
 }
 }
 }
-lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
@@ -1560,7 +1594,7 @@ return x_26;
 }
 }
 }
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
@@ -1572,68 +1606,68 @@ x_6 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_ppExpr), 8, 3);
 lean_closure_set(x_6, 0, x_4);
 lean_closure_set(x_6, 1, x_5);
 lean_closure_set(x_6, 2, x_2);
-x_7 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____spec__1), 6, 1);
+x_7 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____spec__1), 6, 1);
 lean_closure_set(x_7, 0, x_6);
 x_8 = l_Lean_PPContext_runMetaM___rarg(x_1, x_7, x_3);
 lean_dec(x_1);
 return x_8;
 }
 }
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_4 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_ppTerm), 4, 1);
 lean_closure_set(x_4, 0, x_2);
-x_5 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____spec__2), 4, 1);
+x_5 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____spec__2), 4, 1);
 lean_closure_set(x_5, 0, x_4);
 x_6 = l_Lean_PPContext_runCoreM___rarg(x_1, x_5, x_3);
 return x_6;
 }
 }
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_4 = lean_alloc_closure((void*)(l_Lean_Meta_ppGoal___boxed), 6, 1);
 lean_closure_set(x_4, 0, x_2);
-x_5 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____spec__1), 6, 1);
+x_5 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_0__Lean_PrettyPrinter_withoutContext___at_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____spec__1), 6, 1);
 lean_closure_set(x_5, 0, x_4);
 x_6 = l_Lean_PPContext_runMetaM___rarg(x_1, x_5, x_3);
 return x_6;
 }
 }
-static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__1() {
+static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__1), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__2() {
+static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__2___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__2___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__3() {
+static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__3___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__3___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__4() {
+static lean_object* _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__1;
-x_2 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__2;
-x_3 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__3;
+x_1 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__1;
+x_2 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__2;
+x_3 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__3;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -1641,12 +1675,12 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338_(lean_object* x_1) {
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; uint8_t x_5; 
 x_2 = l_Lean_ppFnsRef;
-x_3 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__4;
+x_3 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__4;
 x_4 = lean_st_ref_set(x_2, x_3, x_1);
 x_5 = !lean_is_exclusive(x_4);
 if (x_5 == 0)
@@ -1668,25 +1702,25 @@ return x_8;
 }
 }
 }
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__2(x_1, x_2, x_3);
+x_4 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__2(x_1, x_2, x_3);
 lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____lambda__3(x_1, x_2, x_3);
+x_4 = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____lambda__3(x_1, x_2, x_3);
 lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_377_(lean_object* x_1) {
+lean_object* l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_380_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -1766,24 +1800,30 @@ lean_dec_ref(res);
 res = initialize_Lean_ParserCompiler(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+l_Lean_PPContext_runCoreM___rarg___closed__1 = _init_l_Lean_PPContext_runCoreM___rarg___closed__1();
+lean_mark_persistent(l_Lean_PPContext_runCoreM___rarg___closed__1);
+l_Lean_PPContext_runCoreM___rarg___closed__2 = _init_l_Lean_PPContext_runCoreM___rarg___closed__2();
+lean_mark_persistent(l_Lean_PPContext_runCoreM___rarg___closed__2);
+l_Lean_PPContext_runCoreM___rarg___closed__3 = _init_l_Lean_PPContext_runCoreM___rarg___closed__3();
+lean_mark_persistent(l_Lean_PPContext_runCoreM___rarg___closed__3);
 l_Lean_PrettyPrinter_ppExpr___closed__1 = _init_l_Lean_PrettyPrinter_ppExpr___closed__1();
 lean_mark_persistent(l_Lean_PrettyPrinter_ppExpr___closed__1);
 l_Lean_PrettyPrinter_ppModule___closed__1 = _init_l_Lean_PrettyPrinter_ppModule___closed__1();
 lean_mark_persistent(l_Lean_PrettyPrinter_ppModule___closed__1);
 l_Lean_PrettyPrinter_ppModule___closed__2 = _init_l_Lean_PrettyPrinter_ppModule___closed__2();
 lean_mark_persistent(l_Lean_PrettyPrinter_ppModule___closed__2);
-l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__1 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__1();
-lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__1);
-l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__2 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__2();
-lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__2);
-l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__3 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__3();
-lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__3);
-l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__4 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__4();
-lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338____closed__4);
-res = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_338_(lean_io_mk_world());
+l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__1 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__1();
+lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__1);
+l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__2 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__2();
+lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__2);
+l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__3 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__3();
+lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__3);
+l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__4 = _init_l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__4();
+lean_mark_persistent(l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341____closed__4);
+res = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_341_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-res = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_377_(lean_io_mk_world());
+res = l_Lean_PrettyPrinter_initFn____x40_Lean_PrettyPrinter___hyg_380_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 l_Lean_PrettyPrinter_registerParserCompilers___closed__1 = _init_l_Lean_PrettyPrinter_registerParserCompilers___closed__1();
diff --git a/stage0/stdlib/Lean/PrettyPrinter/Delaborator/Builtins.c b/stage0/stdlib/Lean/PrettyPrinter/Delaborator/Builtins.c
index 7c58ec59a6..51f0fdcf2f 100644
--- a/stage0/stdlib/Lean/PrettyPrinter/Delaborator/Builtins.c
+++ b/stage0/stdlib/Lean/PrettyPrinter/Delaborator/Builtins.c
@@ -23,6 +23,7 @@ extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_1585
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabDIte___closed__1;
 uint8_t lean_local_ctx_uses_user_name(lean_object*, lean_object*);
+lean_object* l_Lean_Meta_forallTelescopeReducing___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__9;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabTuple___closed__1;
 size_t l_USize_add(size_t, size_t);
@@ -120,12 +121,12 @@ lean_object* l_Array_mapIdxM_map___at___private_Lean_PrettyPrinter_Delaborator_B
 extern lean_object* l_Lean_identKind___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabProjectionApp___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabLetE___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppWithUnexpander_go___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_PrettyPrinter_Delaborator_delabAppMatch___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabAppMatch(lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14569____closed__6;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabConst___closed__3;
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda(lean_object*);
 lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabMData___closed__1;
 extern lean_object* l_Lean_Parser_Term_subst___elambda__1___closed__1;
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders(lean_object*);
@@ -194,7 +195,6 @@ lean_object* l_Lean_PrettyPrinter_Delaborator_delabLam_match__1___rarg___boxed(l
 lean_object* l_Lean_Meta_withLetDecl___at_Lean_PrettyPrinter_Delaborator_delabLetE___spec__1(lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_getParamKinds_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_reifyName___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__16;
 extern lean_object* l_Lean_PrettyPrinter_Delaborator_withAppFn___rarg___closed__1;
 uint8_t l_Lean_Name_isPrefixOf(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getOptParamDefault_x3f(lean_object*);
@@ -278,10 +278,13 @@ lean_object* l_Lean_PrettyPrinter_Delaborator_delabStructureInstance___closed__2
 uint8_t l_Array_anyMUnsafe_any___at_Lean_PrettyPrinter_Delaborator_delabForall___spec__9(lean_object*, lean_object*, size_t, size_t);
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_unresolveUsingNamespace_match__1(lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__2;
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_withProj___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabIte___closed__2;
+lean_object* l_Lean_mkAppN(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabOfScientific(lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Lean_PrettyPrinter_Delaborator_hasIdent___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_PrettyPrinter_Delaborator_delabAppMatch___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabDo(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14569____closed__4;
@@ -292,7 +295,7 @@ lean_object* l_Lean_PrettyPrinter_Delaborator_delabListToArray___closed__2;
 lean_object* l_Lean_Syntax_mkApp(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabConst___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabTuple___closed__2;
-lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1(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_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
@@ -308,6 +311,7 @@ lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_withBindingDomain___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabOfScientific___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__15;
 lean_object* l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__2___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabBinders(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabMVar___closed__3;
@@ -343,6 +347,7 @@ extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__9;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabMData___closed__1;
 lean_object* l_Lean_getConstInfo___at_Lean_PrettyPrinter_Delaborator_delabAppMatch___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_12862____closed__10;
+lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_15852____closed__4;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabDo___closed__1;
 lean_object* l_Lean_PrettyPrinter_Delaborator_withAppFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -366,12 +371,12 @@ lean_object* l_Lean_PrettyPrinter_Delaborator_delabConst___lambda__2(lean_object
 lean_object* l_Lean_PrettyPrinter_Delaborator_reifyName_match__1___rarg(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_PrettyPrinter_Delaborator_delabCoe___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, 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*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabBVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_14133____closed__8;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabConst___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
 extern lean_object* l_Lean_Parser_Term_notFollowedByRedefinedTermToken___elambda__1___closed__43;
-extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabListToArray___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns_usingNamesAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabTuple___lambda__1___closed__1;
@@ -436,6 +441,7 @@ lean_object* l_Array_mapMUnsafe_map___at_Lean_PrettyPrinter_Delaborator_delabApp
 extern lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit_match__2(lean_object*);
 lean_object* l_Lean_getStructureFields(lean_object*, lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_shouldGroupWithNext___closed__2;
 lean_object* lean_array_to_list(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabDIte_delabBranch(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -460,6 +466,7 @@ lean_object* l_Lean_PrettyPrinter_Delaborator_getParamKinds___closed__1;
 uint8_t l_Lean_Expr_isAppOfArity(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabLetE___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getRevAliases(lean_object*, lean_object*);
+extern lean_object* l_Lean_instInhabitedExpr;
 lean_object* l_Lean_ScopedEnvExtension_getState___at_Lean_PrettyPrinter_Delaborator_delabAppWithUnexpander_go___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_13362____closed__3;
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns_usingNames(lean_object*);
@@ -467,6 +474,7 @@ lean_object* l_Lean_PrettyPrinter_Delaborator_delabDoElems___lambda__4___boxed(l
 extern lean_object* l___private_Init_Meta_0__Lean_quoteNameMk___closed__3;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit___closed__3;
 size_t lean_usize_modn(size_t, lean_object*);
+extern lean_object* l_Lean_instToExprUnit___lambda__1___closed__3;
 lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabNil___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabProjectionApp___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkSimpleThunk___closed__1;
@@ -484,7 +492,9 @@ lean_object* l_Lean_PrettyPrinter_Delaborator_delabStructureInstance_match__1___
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppMatch_match__2___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_unresolveOpenDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedSyntax;
+uint8_t l_Lean_Expr_isConstOf(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_getUnusedName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabEqRec(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabSorryAx___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppImplicit___closed__7;
@@ -620,6 +630,7 @@ uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabForall___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabCoeFun___closed__1;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppImplicit___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_mkApp(lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppImplicit___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabLetE_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBNode_isRed___rarg(lean_object*);
@@ -783,16 +794,18 @@ lean_object* l_Lean_Expr_getAppFn(lean_object*);
 extern lean_object* l_Lean_PrettyPrinter_Delaborator_getExprKind___closed__9;
 extern lean_object* l_Lean_Parser_Term_doPatDecl___elambda__1___closed__2;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabLam___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppWithUnexpander___closed__1;
 lean_object* l_Lean_throwError___at_Lean_PrettyPrinter_Delaborator_delabAppMatch___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabSort_match__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_ReaderT_pure___at_Lean_PrettyPrinter_Delaborator_instMonadQuotationDelabM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabLetE_match__1(lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_12862____closed__1;
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabBinders___closed__1;
 uint8_t l_List_isEmpty___rarg(lean_object*);
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__1;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit___closed__4;
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppImplicit___closed__5;
 lean_object* l_Lean_PrettyPrinter_Delaborator_getExpr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -860,6 +873,7 @@ lean_object* l_Lean_getPPStructureProjections___boxed(lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_failure___rarg(lean_object*);
 lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppMatch___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_addParenHeuristic___closed__1;
+lean_object* l_Lean_Meta_forallTelescopeReducing___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___spec__1(lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_shouldGroupWithNext_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_unresolveUsingNamespace___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabProjectionApp(lean_object*);
@@ -1677,7 +1691,7 @@ if (x_32 == 0)
 {
 lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
 x_33 = lean_ctor_get(x_31, 0);
-x_34 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_34 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_35 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_35, 0, x_33);
 lean_ctor_set(x_35, 1, x_34);
@@ -1685,7 +1699,7 @@ x_36 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_37 = lean_array_push(x_36, x_35);
 x_38 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
 x_39 = lean_array_push(x_37, x_38);
-x_40 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_40 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_41 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_41, 0, x_40);
 lean_ctor_set(x_41, 1, x_39);
@@ -1700,7 +1714,7 @@ x_43 = lean_ctor_get(x_31, 1);
 lean_inc(x_43);
 lean_inc(x_42);
 lean_dec(x_31);
-x_44 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_44 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_45 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_45, 0, x_42);
 lean_ctor_set(x_45, 1, x_44);
@@ -1708,7 +1722,7 @@ x_46 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_47 = lean_array_push(x_46, x_45);
 x_48 = l_myMacro____x40_Init_Notation___hyg_1318____closed__9;
 x_49 = lean_array_push(x_47, x_48);
-x_50 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_50 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_51 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_51, 0, x_50);
 lean_ctor_set(x_51, 1, x_49);
@@ -1807,7 +1821,7 @@ if (x_89 == 0)
 {
 lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_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_88, 0);
-x_91 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_91 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_92 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_92, 0, x_90);
 lean_ctor_set(x_92, 1, x_91);
@@ -1822,7 +1836,7 @@ lean_ctor_set(x_98, 1, x_96);
 x_99 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_100 = lean_array_push(x_99, x_92);
 x_101 = lean_array_push(x_100, x_98);
-x_102 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_102 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_103 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_103, 0, x_102);
 lean_ctor_set(x_103, 1, x_101);
@@ -1837,7 +1851,7 @@ x_105 = lean_ctor_get(x_88, 1);
 lean_inc(x_105);
 lean_inc(x_104);
 lean_dec(x_88);
-x_106 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_106 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_107 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_107, 0, x_104);
 lean_ctor_set(x_107, 1, x_106);
@@ -1852,7 +1866,7 @@ lean_ctor_set(x_113, 1, x_111);
 x_114 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_115 = lean_array_push(x_114, x_107);
 x_116 = lean_array_push(x_115, x_113);
-x_117 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_117 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_118 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_118, 0, x_117);
 lean_ctor_set(x_118, 1, x_116);
@@ -1952,7 +1966,7 @@ if (x_156 == 0)
 {
 lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; 
 x_157 = lean_ctor_get(x_155, 0);
-x_158 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_158 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_159 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_159, 0, x_157);
 lean_ctor_set(x_159, 1, x_158);
@@ -1967,7 +1981,7 @@ lean_ctor_set(x_165, 1, x_163);
 x_166 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_167 = lean_array_push(x_166, x_159);
 x_168 = lean_array_push(x_167, x_165);
-x_169 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_169 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_170 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_170, 0, x_169);
 lean_ctor_set(x_170, 1, x_168);
@@ -1982,7 +1996,7 @@ x_172 = lean_ctor_get(x_155, 1);
 lean_inc(x_172);
 lean_inc(x_171);
 lean_dec(x_155);
-x_173 = l_Lean_Parser_Term_type___elambda__1___closed__16;
+x_173 = l_Lean_Parser_Term_type___elambda__1___closed__15;
 x_174 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_174, 0, x_171);
 lean_ctor_set(x_174, 1, x_173);
@@ -1997,7 +2011,7 @@ lean_ctor_set(x_180, 1, x_178);
 x_181 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_182 = lean_array_push(x_181, x_174);
 x_183 = lean_array_push(x_182, x_180);
-x_184 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_184 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_185 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_185, 0, x_184);
 lean_ctor_set(x_185, 1, x_183);
@@ -6994,15 +7008,167 @@ lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___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* l_Lean_Meta_forallTelescopeReducing___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___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, lean_object* x_8) {
 _start:
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_11 = l_Lean_Syntax_getId(x_4);
-x_12 = lean_array_push(x_1, x_11);
-x_13 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg(x_2, x_3, x_12, x_5, x_6, x_7, x_8, x_9, x_10);
+lean_object* x_9; lean_object* x_10; 
+x_9 = lean_alloc_closure((void*)(l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__2___rarg___lambda__1), 9, 2);
+lean_closure_set(x_9, 0, x_2);
+lean_closure_set(x_9, 1, x_3);
+x_10 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingImp___rarg(x_1, x_9, x_4, x_5, x_6, x_7, x_8);
+if (lean_obj_tag(x_10) == 0)
+{
+uint8_t x_11; 
+x_11 = !lean_is_exclusive(x_10);
+if (x_11 == 0)
+{
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_12 = lean_ctor_get(x_10, 0);
+x_13 = lean_ctor_get(x_10, 1);
+lean_inc(x_13);
+lean_inc(x_12);
+lean_dec(x_10);
+x_14 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_14, 0, x_12);
+lean_ctor_set(x_14, 1, x_13);
+return x_14;
+}
+}
+else
+{
+uint8_t x_15; 
+x_15 = !lean_is_exclusive(x_10);
+if (x_15 == 0)
+{
+return x_10;
+}
+else
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_16 = lean_ctor_get(x_10, 0);
+x_17 = lean_ctor_get(x_10, 1);
+lean_inc(x_17);
+lean_inc(x_16);
+lean_dec(x_10);
+x_18 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_18, 0, x_16);
+lean_ctor_set(x_18, 1, x_17);
+return x_18;
+}
+}
+}
+}
+lean_object* l_Lean_Meta_forallTelescopeReducing___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___spec__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Meta_forallTelescopeReducing___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___spec__1___rarg), 8, 0);
+return x_2;
+}
+}
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___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) {
+_start:
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_10 = l_Lean_instInhabitedExpr;
+x_11 = lean_unsigned_to_nat(0u);
+x_12 = lean_array_get(x_10, x_2, x_11);
+lean_inc(x_8);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+x_13 = l_Lean_Meta_inferType(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; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_13, 1);
+lean_inc(x_15);
+lean_dec(x_13);
+x_16 = lean_array_get_size(x_2);
+x_17 = lean_unsigned_to_nat(1u);
+x_18 = lean_nat_dec_eq(x_16, x_17);
+lean_dec(x_16);
+if (x_18 == 0)
+{
+lean_object* x_19; uint8_t x_20; uint8_t x_21; lean_object* x_22; 
+lean_dec(x_14);
+x_19 = l_Lean_mkAppN(x_1, x_2);
+x_20 = 0;
+x_21 = 1;
+x_22 = l_Lean_Meta_mkLambdaFVars(x_2, x_19, x_20, x_21, x_5, x_6, x_7, x_8, x_15);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+return x_22;
+}
+else
+{
+lean_object* x_23; uint8_t x_24; 
+x_23 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
+x_24 = l_Lean_Expr_isConstOf(x_14, x_23);
+lean_dec(x_14);
+if (x_24 == 0)
+{
+lean_object* x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; 
+x_25 = l_Lean_mkAppN(x_1, x_2);
+x_26 = 0;
+x_27 = 1;
+x_28 = l_Lean_Meta_mkLambdaFVars(x_2, x_25, x_26, x_27, x_5, x_6, x_7, x_8, x_15);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+return x_28;
+}
+else
+{
+lean_object* x_29; lean_object* x_30; uint8_t x_31; uint8_t x_32; lean_object* x_33; 
+x_29 = l_Lean_instToExprUnit___lambda__1___closed__3;
+x_30 = l_Lean_mkApp(x_1, x_29);
+x_31 = 0;
+x_32 = 1;
+x_33 = l_Lean_Meta_mkLambdaFVars(x_2, x_30, x_31, x_32, x_5, x_6, x_7, x_8, x_15);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+return x_33;
+}
+}
+}
+else
+{
+uint8_t x_34; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_2);
+lean_dec(x_1);
+x_34 = !lean_is_exclusive(x_13);
+if (x_34 == 0)
+{
 return x_13;
 }
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_35 = lean_ctor_get(x_13, 0);
+x_36 = lean_ctor_get(x_13, 1);
+lean_inc(x_36);
+lean_inc(x_35);
+lean_dec(x_13);
+x_37 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_37, 0, x_35);
+lean_ctor_set(x_37, 1, x_36);
+return x_37;
+}
+}
+}
 }
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___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:
@@ -7012,7 +7178,7 @@ x_10 = lean_unsigned_to_nat(0u);
 x_11 = lean_nat_dec_eq(x_2, x_10);
 if (x_11 == 0)
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; 
 x_12 = lean_unsigned_to_nat(1u);
 x_13 = lean_nat_sub(x_2, x_12);
 x_14 = l_Lean_PrettyPrinter_Delaborator_getExpr(x_4, x_5, x_6, x_7, x_8, x_9);
@@ -7021,42 +7187,153 @@ lean_inc(x_15);
 x_16 = lean_ctor_get(x_14, 1);
 lean_inc(x_16);
 lean_dec(x_14);
-x_17 = l_Lean_Expr_bindingName_x21(x_15);
-lean_dec(x_15);
-x_18 = lean_erase_macro_scopes(x_17);
-x_19 = l_Array_contains___at_Lean_findField_x3f___spec__1(x_3, x_18);
-if (x_19 == 0)
+x_17 = l_Lean_Expr_isLambda(x_15);
+if (x_17 == 0)
 {
-lean_object* x_20; lean_object* x_21; 
+lean_object* x_18; 
+lean_inc(x_8);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_15);
+x_18 = l_Lean_Meta_inferType(x_15, x_5, x_6, x_7, x_8, x_16);
+if (lean_obj_tag(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_18, 0);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_18, 1);
+lean_inc(x_20);
 lean_dec(x_18);
-x_20 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1___boxed), 10, 3);
-lean_closure_set(x_20, 0, x_3);
-lean_closure_set(x_20, 1, x_1);
-lean_closure_set(x_20, 2, x_13);
-x_21 = l_Lean_PrettyPrinter_Delaborator_withBindingBodyUnusedName___rarg(x_20, x_4, x_5, x_6, x_7, x_8, x_16);
-return x_21;
-}
-else
+x_21 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1___boxed), 9, 1);
+lean_closure_set(x_21, 0, x_15);
+lean_inc(x_8);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+x_22 = l_Lean_Meta_forallTelescopeReducing___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___spec__1___rarg(x_19, x_21, x_4, x_5, x_6, x_7, x_8, x_20);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_22 = lean_ctor_get(x_5, 1);
-lean_inc(x_22);
-x_23 = lean_local_ctx_get_unused_name(x_22, x_18);
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 0);
 lean_inc(x_23);
-x_24 = lean_array_push(x_3, x_23);
-x_25 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___boxed), 9, 3);
-lean_closure_set(x_25, 0, x_1);
-lean_closure_set(x_25, 1, x_13);
-lean_closure_set(x_25, 2, x_24);
-x_26 = l_Lean_PrettyPrinter_Delaborator_withBindingBody___rarg(x_23, x_25, x_4, x_5, x_6, x_7, x_8, x_16);
-return x_26;
+x_24 = lean_ctor_get(x_22, 1);
+lean_inc(x_24);
+lean_dec(x_22);
+x_25 = !lean_is_exclusive(x_4);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+x_26 = lean_ctor_get(x_4, 0);
+lean_dec(x_26);
+lean_ctor_set(x_4, 0, x_23);
+x_27 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg(x_1, x_13, x_3, x_4, x_5, x_6, x_7, x_8, x_24);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; 
+x_28 = lean_ctor_get(x_4, 1);
+x_29 = lean_ctor_get(x_4, 2);
+x_30 = lean_ctor_get(x_4, 3);
+x_31 = lean_ctor_get(x_4, 4);
+x_32 = lean_ctor_get(x_4, 5);
+x_33 = lean_ctor_get_uint8(x_4, sizeof(void*)*6);
+lean_inc(x_32);
+lean_inc(x_31);
+lean_inc(x_30);
+lean_inc(x_29);
+lean_inc(x_28);
+lean_dec(x_4);
+x_34 = lean_alloc_ctor(0, 6, 1);
+lean_ctor_set(x_34, 0, x_23);
+lean_ctor_set(x_34, 1, x_28);
+lean_ctor_set(x_34, 2, x_29);
+lean_ctor_set(x_34, 3, x_30);
+lean_ctor_set(x_34, 4, x_31);
+lean_ctor_set(x_34, 5, x_32);
+lean_ctor_set_uint8(x_34, sizeof(void*)*6, x_33);
+x_35 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg(x_1, x_13, x_3, x_34, x_5, x_6, x_7, x_8, x_24);
+return x_35;
 }
 }
 else
 {
-lean_object* x_27; 
-x_27 = lean_apply_7(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
-return x_27;
+uint8_t x_36; 
+lean_dec(x_13);
+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_36 = !lean_is_exclusive(x_22);
+if (x_36 == 0)
+{
+return x_22;
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_37 = lean_ctor_get(x_22, 0);
+x_38 = lean_ctor_get(x_22, 1);
+lean_inc(x_38);
+lean_inc(x_37);
+lean_dec(x_22);
+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_40; 
+lean_dec(x_15);
+lean_dec(x_13);
+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_40 = !lean_is_exclusive(x_18);
+if (x_40 == 0)
+{
+return x_18;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_41 = lean_ctor_get(x_18, 0);
+x_42 = lean_ctor_get(x_18, 1);
+lean_inc(x_42);
+lean_inc(x_41);
+lean_dec(x_18);
+x_43 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_43, 0, x_41);
+lean_ctor_set(x_43, 1, x_42);
+return x_43;
+}
+}
+}
+else
+{
+lean_object* x_44; 
+lean_dec(x_15);
+x_44 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg(x_1, x_13, x_3, x_4, x_5, x_6, x_7, x_8, x_16);
+return x_44;
+}
+}
+else
+{
+lean_object* x_45; 
+x_45 = lean_apply_7(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+return x_45;
 }
 }
 }
@@ -7068,14 +7345,74 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Buil
 return x_2;
 }
 }
-lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___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) {
 _start:
 {
-lean_object* x_11; 
-x_11 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_11 = l_Lean_Syntax_getId(x_4);
+x_12 = lean_array_push(x_1, x_11);
+x_13 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg(x_2, x_3, x_12, x_5, x_6, x_7, x_8, x_9, x_10);
+return x_13;
+}
+}
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___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; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_10 = l_Lean_PrettyPrinter_Delaborator_getExpr(x_4, x_5, x_6, x_7, x_8, x_9);
+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 = l_Lean_Expr_bindingName_x21(x_11);
+lean_dec(x_11);
+x_14 = lean_erase_macro_scopes(x_13);
+x_15 = l_Array_contains___at_Lean_findField_x3f___spec__1(x_3, x_14);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; 
+lean_dec(x_14);
+x_16 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg___lambda__1___boxed), 10, 3);
+lean_closure_set(x_16, 0, x_3);
+lean_closure_set(x_16, 1, x_1);
+lean_closure_set(x_16, 2, x_2);
+x_17 = l_Lean_PrettyPrinter_Delaborator_withBindingBodyUnusedName___rarg(x_16, x_4, x_5, x_6, x_7, x_8, x_12);
+return x_17;
+}
+else
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_5, 1);
+lean_inc(x_18);
+x_19 = lean_local_ctx_get_unused_name(x_18, x_14);
+lean_inc(x_19);
+x_20 = lean_array_push(x_3, x_19);
+x_21 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___boxed), 9, 3);
+lean_closure_set(x_21, 0, x_1);
+lean_closure_set(x_21, 1, x_2);
+lean_closure_set(x_21, 2, x_20);
+x_22 = l_Lean_PrettyPrinter_Delaborator_withBindingBody___rarg(x_19, x_21, x_4, x_5, x_6, x_7, x_8, x_12);
+return x_22;
+}
+}
+}
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg), 9, 0);
+return x_2;
+}
+}
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___rarg___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
 lean_dec(x_4);
 lean_dec(x_3);
-return x_11;
+return x_10;
 }
 }
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop___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, lean_object* x_8, lean_object* x_9) {
@@ -7087,6 +7424,16 @@ lean_dec(x_2);
 return x_10;
 }
 }
+lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
+_start:
+{
+lean_object* x_11; 
+x_11 = l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders_loop_visitLambda___rarg___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_11;
+}
+}
 lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_skippingBinders___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) {
 _start:
 {
@@ -11844,7 +12191,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_delabMData___closed__1;
-x_3 = lean_unsigned_to_nat(277u);
+x_3 = lean_unsigned_to_nat(293u);
 x_4 = lean_unsigned_to_nat(37u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13894,7 +14241,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_delabLam___lambda__3___closed__1;
-x_3 = lean_unsigned_to_nat(362u);
+x_3 = lean_unsigned_to_nat(378u);
 x_4 = lean_unsigned_to_nat(44u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -17150,7 +17497,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(398u);
+x_3 = lean_unsigned_to_nat(414u);
 x_4 = lean_unsigned_to_nat(38u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -17257,7 +17604,7 @@ lean_ctor_set(x_37, 1, x_36);
 x_38 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_39 = lean_array_push(x_38, x_37);
 x_40 = lean_array_push(x_39, x_20);
-x_41 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_41 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_42 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_42, 0, x_41);
 lean_ctor_set(x_42, 1, x_40);
@@ -17330,7 +17677,7 @@ lean_ctor_set(x_78, 1, x_77);
 x_79 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_80 = lean_array_push(x_79, x_78);
 x_81 = lean_array_push(x_80, x_20);
-x_82 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_82 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_83 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_83, 0, x_82);
 lean_ctor_set(x_83, 1, x_81);
@@ -17600,7 +17947,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(409u);
+x_3 = lean_unsigned_to_nat(425u);
 x_4 = lean_unsigned_to_nat(31u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -19057,7 +19404,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(448u);
+x_3 = lean_unsigned_to_nat(464u);
 x_4 = lean_unsigned_to_nat(38u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -24646,7 +24993,7 @@ lean_ctor_set(x_15, 1, x_14);
 x_16 = l_myMacro____x40_Init_Notation___hyg_1318____closed__8;
 x_17 = lean_array_push(x_16, x_15);
 x_18 = lean_array_push(x_17, x_2);
-x_19 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__7;
+x_19 = l_Lean_Parser_Tactic_myMacro____x40_Init_Notation___hyg_17244____closed__5;
 x_20 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_20, 0, x_19);
 lean_ctor_set(x_20, 1, x_18);
@@ -24848,7 +25195,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__1;
-x_3 = lean_unsigned_to_nat(598u);
+x_3 = lean_unsigned_to_nat(614u);
 x_4 = lean_unsigned_to_nat(40u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
diff --git a/stage0/stdlib/Lean/ReducibilityAttrs.c b/stage0/stdlib/Lean/ReducibilityAttrs.c
index cc4ed76ce1..79e73b0da2 100644
--- a/stage0/stdlib/Lean/ReducibilityAttrs.c
+++ b/stage0/stdlib/Lean/ReducibilityAttrs.c
@@ -58,7 +58,6 @@ lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_isReducible_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_initFn____x40_Lean_ReducibilityAttrs___hyg_88____spec__1___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_isReducible_match__1___rarg(uint8_t, lean_object*, lean_object*);
-extern lean_object* l_Int_Int_pow___closed__1;
 lean_object* l___private_Lean_ReducibilityAttrs_0__Lean_reprReducibilityStatus____x40_Lean_ReducibilityAttrs___hyg_11__match__1(lean_object*);
 lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_ReducibilityAttrs___hyg_88____spec__2___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerTagAttribute___closed__5;
@@ -166,6 +165,7 @@ lean_object* l_Lean_registerEnumAttributes___at_Lean_initFn____x40_Lean_Reducibi
 lean_object* l_Lean_registerEnumAttributes___at_Lean_initFn____x40_Lean_ReducibilityAttrs___hyg_88____spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_isReducible___rarg___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_ReducibilityAttrs_0__Lean_reprReducibilityStatus____x40_Lean_ReducibilityAttrs___hyg_11____closed__11;
+extern lean_object* l_Int_pow___closed__1;
 extern lean_object* l_Array_qsort_sort___at_Lean_mkMapDeclarationExtension___spec__1___rarg___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Repr_addAppParen(lean_object*, lean_object*);
@@ -275,7 +275,7 @@ static lean_object* _init_l___private_Lean_ReducibilityAttrs_0__Lean_reprReducib
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_ReducibilityAttrs_0__Lean_reprReducibilityStatus____x40_Lean_ReducibilityAttrs___hyg_11____closed__2;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -341,7 +341,7 @@ static lean_object* _init_l___private_Lean_ReducibilityAttrs_0__Lean_reprReducib
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_ReducibilityAttrs_0__Lean_reprReducibilityStatus____x40_Lean_ReducibilityAttrs___hyg_11____closed__8;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
@@ -407,7 +407,7 @@ static lean_object* _init_l___private_Lean_ReducibilityAttrs_0__Lean_reprReducib
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Int_Int_pow___closed__1;
+x_1 = l_Int_pow___closed__1;
 x_2 = l___private_Lean_ReducibilityAttrs_0__Lean_reprReducibilityStatus____x40_Lean_ReducibilityAttrs___hyg_11____closed__14;
 x_3 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
diff --git a/stage0/stdlib/Lean/ResolveName.c b/stage0/stdlib/Lean/ResolveName.c
index 5465cde310..8dbf5895d9 100644
--- a/stage0/stdlib/Lean/ResolveName.c
+++ b/stage0/stdlib/Lean/ResolveName.c
@@ -175,7 +175,7 @@ lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_
 lean_object* l_Lean_instMonadResolveName(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAux___at_Lean_addAliasEntry___spec__3(lean_object*, size_t, lean_object*);
 size_t l_USize_mul(size_t, size_t);
-extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+extern lean_object* l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 lean_object* l_Lean_ResolveName_resolveGlobalName(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ResolveName_resolveGlobalName_loop_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getAliases(lean_object*, lean_object*);
@@ -2056,7 +2056,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_initFn____x40_Lean_ResolveName___hyg_55____closed__2;
 x_2 = l_Lean_initFn____x40_Lean_ResolveName___hyg_55____closed__3;
 x_3 = l_Lean_initFn____x40_Lean_ResolveName___hyg_55____closed__4;
-x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3630____closed__4;
+x_4 = l_Lean_initFn____x40_Lean_Environment___hyg_3629____closed__4;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
diff --git a/stage0/stdlib/Lean/Server/Completion.c b/stage0/stdlib/Lean/Server/Completion.c
index f0179a2eea..a8e7e41194 100644
--- a/stage0/stdlib/Lean/Server/Completion.c
+++ b/stage0/stdlib/Lean/Server/Completion.c
@@ -112,7 +112,7 @@ lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idComp
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__38___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___private_Lean_Server_Completion_0__Lean_Server_Completion_normPrivateName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_forIn___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__36___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 extern lean_object* l_Lean_auxRecExt;
 uint8_t l_Lean_isPrivateName(lean_object*);
@@ -122,7 +122,6 @@ lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_addCom
 lean_object* lean_nat_add(lean_object*, lean_object*);
 extern lean_object* l_Lean_LocalContext_mkEmpty___closed__1;
 extern lean_object* l_Lean_Parser_instInhabitedParserCategory;
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__3;
 lean_object* l_Lean_Server_Completion_completionBlackListExt___elambda__3___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Server_Completion_find_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__40(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*);
@@ -133,7 +132,6 @@ lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_addCom
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_runM___closed__1;
 lean_object* l_Std_PersistentHashMap_forM___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__32(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_qpartition_loop___at___private_Lean_Server_Completion_0__Lean_Server_Completion_sortCompletionItems___spec__2(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_Server_Completion_0__Lean_Server_Completion_runM___closed__2;
 uint8_t l_Lean_Elab_Info_isCompletion(lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___lambda__3(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -270,6 +268,7 @@ lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_isDotC
 lean_object* l_Std_PersistentHashMap_foldlM___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__28(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames_visit(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1;
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable_match__2___rarg(lean_object*, lean_object*);
 uint8_t l___private_Lean_Server_Completion_0__Lean_Server_Completion_matchAtomic(lean_object*, lean_object*);
 lean_object* l_Array_qsort_sort___at___private_Lean_Server_Completion_0__Lean_Server_Completion_sortCompletionItems___spec__1___lambda__1___boxed(lean_object*, lean_object*);
@@ -292,10 +291,8 @@ lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_isType
 lean_object* l_Std_PersistentHashMap_foldlM___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__28___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_sortCompletionItems(lean_object*);
 uint8_t l_Lean_Name_isAnonymous(lean_object*);
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__1;
 lean_object* lean_data_value_to_string(lean_object*);
 lean_object* lean_panic_fn(lean_object*, lean_object*);
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__2;
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_qpartition_loop___at___private_Lean_Server_Completion_0__Lean_Server_Completion_sortCompletionItems___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore_match__1(lean_object*);
@@ -309,7 +306,6 @@ lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idComp
 lean_object* l_Lean_SMap_forM___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__20(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__16(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_getPrefix(lean_object*);
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletion(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Tactic_tactic___x3c_x3b_x3e_____closed__6;
@@ -337,7 +333,6 @@ lean_object* l_Lean_Server_Completion_completionBlackListExt___elambda__1(lean_o
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames_visit_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_completion_add_to_black_list(lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Info_fmtHover_x3f___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_Completion_initFn____x40_Lean_Server_Completion___hyg_6____closed__2;
 lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__31(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_Lean_Server_Completion_find_x3f_choose_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -373,8 +368,6 @@ lean_object* l_Lean_Elab_ContextInfo_runMetaM___rarg(lean_object*, lean_object*,
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_Completion_completionBlackListExt___elambda__2(lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore_match__3(lean_object*);
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___closed__1;
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable_match__2(lean_object*);
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_runM___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1323,7 +1316,7 @@ return x_36;
 }
 else
 {
-uint8_t x_37; uint8_t x_38; uint8_t x_39; uint8_t x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; lean_object* x_46; lean_object* x_47; 
+uint8_t x_37; uint8_t x_38; uint8_t x_39; uint8_t x_40; uint8_t x_41; uint8_t x_42; uint8_t x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; lean_object* x_47; lean_object* x_48; 
 x_37 = lean_ctor_get_uint8(x_16, 0);
 x_38 = lean_ctor_get_uint8(x_16, 1);
 x_39 = lean_ctor_get_uint8(x_16, 2);
@@ -1332,198 +1325,202 @@ x_41 = lean_ctor_get_uint8(x_16, 4);
 x_42 = lean_ctor_get_uint8(x_16, 6);
 x_43 = lean_ctor_get_uint8(x_16, 7);
 x_44 = lean_ctor_get_uint8(x_16, 8);
+x_45 = lean_ctor_get_uint8(x_16, 9);
 lean_dec(x_16);
-x_45 = 2;
-x_46 = lean_alloc_ctor(0, 0, 9);
-lean_ctor_set_uint8(x_46, 0, x_37);
-lean_ctor_set_uint8(x_46, 1, x_38);
-lean_ctor_set_uint8(x_46, 2, x_39);
-lean_ctor_set_uint8(x_46, 3, x_40);
-lean_ctor_set_uint8(x_46, 4, x_41);
-lean_ctor_set_uint8(x_46, 5, x_45);
-lean_ctor_set_uint8(x_46, 6, x_42);
-lean_ctor_set_uint8(x_46, 7, x_43);
-lean_ctor_set_uint8(x_46, 8, x_44);
-lean_ctor_set(x_5, 0, x_46);
-x_47 = l_Lean_withoutModifyingState___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__1___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__2(x_2, x_18, x_5, x_6, x_7, x_8, x_17);
-if (lean_obj_tag(x_47) == 0)
+x_46 = 2;
+x_47 = lean_alloc_ctor(0, 0, 10);
+lean_ctor_set_uint8(x_47, 0, x_37);
+lean_ctor_set_uint8(x_47, 1, x_38);
+lean_ctor_set_uint8(x_47, 2, x_39);
+lean_ctor_set_uint8(x_47, 3, x_40);
+lean_ctor_set_uint8(x_47, 4, x_41);
+lean_ctor_set_uint8(x_47, 5, x_46);
+lean_ctor_set_uint8(x_47, 6, x_42);
+lean_ctor_set_uint8(x_47, 7, x_43);
+lean_ctor_set_uint8(x_47, 8, x_44);
+lean_ctor_set_uint8(x_47, 9, x_45);
+lean_ctor_set(x_5, 0, x_47);
+x_48 = l_Lean_withoutModifyingState___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__1___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__2(x_2, x_18, x_5, x_6, x_7, x_8, x_17);
+if (lean_obj_tag(x_48) == 0)
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_48 = lean_ctor_get(x_47, 0);
-lean_inc(x_48);
-x_49 = lean_ctor_get(x_47, 1);
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_49 = lean_ctor_get(x_48, 0);
 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;
+x_50 = lean_ctor_get(x_48, 1);
+lean_inc(x_50);
+if (lean_is_exclusive(x_48)) {
+ lean_ctor_release(x_48, 0);
+ lean_ctor_release(x_48, 1);
+ x_51 = x_48;
 } else {
- lean_dec_ref(x_47);
- x_50 = lean_box(0);
+ lean_dec_ref(x_48);
+ x_51 = lean_box(0);
 }
-x_51 = lean_box(0);
-x_52 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_52, 0, x_48);
-lean_ctor_set(x_52, 1, x_51);
-if (lean_is_scalar(x_50)) {
- x_53 = lean_alloc_ctor(0, 2, 0);
+x_52 = lean_box(0);
+x_53 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_53, 0, x_49);
+lean_ctor_set(x_53, 1, x_52);
+if (lean_is_scalar(x_51)) {
+ x_54 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_53 = x_50;
+ x_54 = x_51;
 }
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_49);
-return x_53;
+lean_ctor_set(x_54, 0, x_53);
+lean_ctor_set(x_54, 1, x_50);
+return x_54;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_54 = lean_ctor_get(x_47, 0);
-lean_inc(x_54);
-x_55 = lean_ctor_get(x_47, 1);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_55 = lean_ctor_get(x_48, 0);
 lean_inc(x_55);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- x_56 = x_47;
+x_56 = lean_ctor_get(x_48, 1);
+lean_inc(x_56);
+if (lean_is_exclusive(x_48)) {
+ lean_ctor_release(x_48, 0);
+ lean_ctor_release(x_48, 1);
+ x_57 = x_48;
 } else {
- lean_dec_ref(x_47);
- x_56 = lean_box(0);
+ lean_dec_ref(x_48);
+ x_57 = lean_box(0);
 }
-if (lean_is_scalar(x_56)) {
- x_57 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_57)) {
+ x_58 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_57 = x_56;
+ x_58 = x_57;
 }
-lean_ctor_set(x_57, 0, x_54);
-lean_ctor_set(x_57, 1, x_55);
-return x_57;
+lean_ctor_set(x_58, 0, x_55);
+lean_ctor_set(x_58, 1, x_56);
+return x_58;
 }
 }
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; uint8_t x_62; uint8_t x_63; uint8_t x_64; uint8_t x_65; uint8_t x_66; uint8_t x_67; uint8_t x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_58 = lean_ctor_get(x_5, 1);
-x_59 = lean_ctor_get(x_5, 2);
-x_60 = lean_ctor_get(x_5, 3);
+lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; uint8_t x_63; uint8_t x_64; uint8_t x_65; uint8_t x_66; uint8_t x_67; uint8_t x_68; uint8_t x_69; uint8_t x_70; lean_object* x_71; uint8_t x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
+x_59 = lean_ctor_get(x_5, 1);
+x_60 = lean_ctor_get(x_5, 2);
+x_61 = lean_ctor_get(x_5, 3);
+lean_inc(x_61);
 lean_inc(x_60);
 lean_inc(x_59);
-lean_inc(x_58);
 lean_dec(x_5);
-x_61 = lean_ctor_get_uint8(x_16, 0);
-x_62 = lean_ctor_get_uint8(x_16, 1);
-x_63 = lean_ctor_get_uint8(x_16, 2);
-x_64 = lean_ctor_get_uint8(x_16, 3);
-x_65 = lean_ctor_get_uint8(x_16, 4);
-x_66 = lean_ctor_get_uint8(x_16, 6);
-x_67 = lean_ctor_get_uint8(x_16, 7);
-x_68 = lean_ctor_get_uint8(x_16, 8);
+x_62 = lean_ctor_get_uint8(x_16, 0);
+x_63 = lean_ctor_get_uint8(x_16, 1);
+x_64 = lean_ctor_get_uint8(x_16, 2);
+x_65 = lean_ctor_get_uint8(x_16, 3);
+x_66 = lean_ctor_get_uint8(x_16, 4);
+x_67 = lean_ctor_get_uint8(x_16, 6);
+x_68 = lean_ctor_get_uint8(x_16, 7);
+x_69 = lean_ctor_get_uint8(x_16, 8);
+x_70 = lean_ctor_get_uint8(x_16, 9);
 if (lean_is_exclusive(x_16)) {
- x_69 = x_16;
+ x_71 = x_16;
 } else {
  lean_dec_ref(x_16);
- x_69 = lean_box(0);
+ x_71 = lean_box(0);
 }
-x_70 = 2;
-if (lean_is_scalar(x_69)) {
- x_71 = lean_alloc_ctor(0, 0, 9);
+x_72 = 2;
+if (lean_is_scalar(x_71)) {
+ x_73 = lean_alloc_ctor(0, 0, 10);
 } else {
- x_71 = x_69;
+ x_73 = x_71;
 }
-lean_ctor_set_uint8(x_71, 0, x_61);
-lean_ctor_set_uint8(x_71, 1, x_62);
-lean_ctor_set_uint8(x_71, 2, x_63);
-lean_ctor_set_uint8(x_71, 3, x_64);
-lean_ctor_set_uint8(x_71, 4, x_65);
-lean_ctor_set_uint8(x_71, 5, x_70);
-lean_ctor_set_uint8(x_71, 6, x_66);
-lean_ctor_set_uint8(x_71, 7, x_67);
-lean_ctor_set_uint8(x_71, 8, x_68);
-x_72 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_72, 0, x_71);
-lean_ctor_set(x_72, 1, x_58);
-lean_ctor_set(x_72, 2, x_59);
-lean_ctor_set(x_72, 3, x_60);
-x_73 = l_Lean_withoutModifyingState___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__1___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__2(x_2, x_18, x_72, x_6, x_7, x_8, x_17);
-if (lean_obj_tag(x_73) == 0)
+lean_ctor_set_uint8(x_73, 0, x_62);
+lean_ctor_set_uint8(x_73, 1, x_63);
+lean_ctor_set_uint8(x_73, 2, x_64);
+lean_ctor_set_uint8(x_73, 3, x_65);
+lean_ctor_set_uint8(x_73, 4, x_66);
+lean_ctor_set_uint8(x_73, 5, x_72);
+lean_ctor_set_uint8(x_73, 6, x_67);
+lean_ctor_set_uint8(x_73, 7, x_68);
+lean_ctor_set_uint8(x_73, 8, x_69);
+lean_ctor_set_uint8(x_73, 9, x_70);
+x_74 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_74, 0, x_73);
+lean_ctor_set(x_74, 1, x_59);
+lean_ctor_set(x_74, 2, x_60);
+lean_ctor_set(x_74, 3, x_61);
+x_75 = l_Lean_withoutModifyingState___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__1___at___private_Lean_Server_Completion_0__Lean_Server_Completion_isTypeApplicable___spec__2(x_2, x_18, x_74, x_6, x_7, x_8, x_17);
+if (lean_obj_tag(x_75) == 0)
 {
-lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
-x_74 = lean_ctor_get(x_73, 0);
-lean_inc(x_74);
-x_75 = lean_ctor_get(x_73, 1);
-lean_inc(x_75);
-if (lean_is_exclusive(x_73)) {
- lean_ctor_release(x_73, 0);
- lean_ctor_release(x_73, 1);
- x_76 = x_73;
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
+x_76 = lean_ctor_get(x_75, 0);
+lean_inc(x_76);
+x_77 = lean_ctor_get(x_75, 1);
+lean_inc(x_77);
+if (lean_is_exclusive(x_75)) {
+ lean_ctor_release(x_75, 0);
+ lean_ctor_release(x_75, 1);
+ x_78 = x_75;
 } else {
- lean_dec_ref(x_73);
- x_76 = lean_box(0);
+ lean_dec_ref(x_75);
+ x_78 = lean_box(0);
 }
-x_77 = lean_box(0);
-x_78 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_78, 0, x_74);
-lean_ctor_set(x_78, 1, x_77);
-if (lean_is_scalar(x_76)) {
- x_79 = lean_alloc_ctor(0, 2, 0);
+x_79 = lean_box(0);
+x_80 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_80, 0, x_76);
+lean_ctor_set(x_80, 1, x_79);
+if (lean_is_scalar(x_78)) {
+ x_81 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_79 = x_76;
+ x_81 = x_78;
 }
-lean_ctor_set(x_79, 0, x_78);
-lean_ctor_set(x_79, 1, x_75);
-return x_79;
+lean_ctor_set(x_81, 0, x_80);
+lean_ctor_set(x_81, 1, x_77);
+return x_81;
 }
 else
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; 
-x_80 = lean_ctor_get(x_73, 0);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_73, 1);
-lean_inc(x_81);
-if (lean_is_exclusive(x_73)) {
- lean_ctor_release(x_73, 0);
- lean_ctor_release(x_73, 1);
- x_82 = x_73;
+lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+x_82 = lean_ctor_get(x_75, 0);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_75, 1);
+lean_inc(x_83);
+if (lean_is_exclusive(x_75)) {
+ lean_ctor_release(x_75, 0);
+ lean_ctor_release(x_75, 1);
+ x_84 = x_75;
 } else {
- lean_dec_ref(x_73);
- x_82 = lean_box(0);
+ lean_dec_ref(x_75);
+ x_84 = lean_box(0);
 }
-if (lean_is_scalar(x_82)) {
- x_83 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_84)) {
+ x_85 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_83 = x_82;
+ x_85 = x_84;
 }
-lean_ctor_set(x_83, 0, x_80);
-lean_ctor_set(x_83, 1, x_81);
-return x_83;
+lean_ctor_set(x_85, 0, x_82);
+lean_ctor_set(x_85, 1, x_83);
+return x_85;
 }
 }
 }
 else
 {
-uint8_t x_84; 
+uint8_t x_86; 
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_2);
-x_84 = !lean_is_exclusive(x_13);
-if (x_84 == 0)
+x_86 = !lean_is_exclusive(x_13);
+if (x_86 == 0)
 {
 return x_13;
 }
 else
 {
-lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-x_85 = lean_ctor_get(x_13, 0);
-x_86 = lean_ctor_get(x_13, 1);
-lean_inc(x_86);
-lean_inc(x_85);
+lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+x_87 = lean_ctor_get(x_13, 0);
+x_88 = lean_ctor_get(x_13, 1);
+lean_inc(x_88);
+lean_inc(x_87);
 lean_dec(x_13);
-x_87 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_87, 0, x_85);
-lean_ctor_set(x_87, 1, x_86);
-return x_87;
+x_89 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_89, 0, x_87);
+lean_ctor_set(x_89, 1, x_88);
+return x_89;
 }
 }
 }
@@ -12116,227 +12113,7 @@ return x_35;
 }
 }
 }
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___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) {
-_start:
-{
-if (lean_obj_tag(x_1) == 0)
-{
-lean_object* x_8; lean_object* x_9; 
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_8 = lean_box(0);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_8);
-lean_ctor_set(x_9, 1, x_7);
-return x_9;
-}
-else
-{
-uint8_t x_10; 
-x_10 = !lean_is_exclusive(x_1);
-if (x_10 == 0)
-{
-lean_object* x_11; lean_object* x_12; 
-x_11 = lean_ctor_get(x_1, 0);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_3);
-x_12 = l_Lean_Meta_instantiateMVars(x_11, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-x_14 = lean_ctor_get(x_12, 1);
-lean_inc(x_14);
-lean_dec(x_12);
-x_15 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames(x_13, x_3, x_4, x_5, x_6, x_14);
-if (lean_obj_tag(x_15) == 0)
-{
-uint8_t x_16; 
-x_16 = !lean_is_exclusive(x_15);
-if (x_16 == 0)
-{
-lean_object* x_17; 
-x_17 = lean_ctor_get(x_15, 0);
-lean_ctor_set(x_1, 0, x_17);
-lean_ctor_set(x_15, 0, x_1);
-return x_15;
-}
-else
-{
-lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-x_18 = lean_ctor_get(x_15, 0);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_dec(x_15);
-lean_ctor_set(x_1, 0, x_18);
-x_20 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_20, 0, x_1);
-lean_ctor_set(x_20, 1, x_19);
-return x_20;
-}
-}
-else
-{
-uint8_t x_21; 
-lean_free_object(x_1);
-x_21 = !lean_is_exclusive(x_15);
-if (x_21 == 0)
-{
-return x_15;
-}
-else
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_22 = lean_ctor_get(x_15, 0);
-x_23 = lean_ctor_get(x_15, 1);
-lean_inc(x_23);
-lean_inc(x_22);
-lean_dec(x_15);
-x_24 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_24, 0, x_22);
-lean_ctor_set(x_24, 1, x_23);
-return x_24;
-}
-}
-}
-else
-{
-uint8_t x_25; 
-lean_free_object(x_1);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_25 = !lean_is_exclusive(x_12);
-if (x_25 == 0)
-{
-return x_12;
-}
-else
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_26 = lean_ctor_get(x_12, 0);
-x_27 = lean_ctor_get(x_12, 1);
-lean_inc(x_27);
-lean_inc(x_26);
-lean_dec(x_12);
-x_28 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_28, 0, x_26);
-lean_ctor_set(x_28, 1, x_27);
-return x_28;
-}
-}
-}
-else
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_1, 0);
-lean_inc(x_29);
-lean_dec(x_1);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_3);
-x_30 = l_Lean_Meta_instantiateMVars(x_29, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-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 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames(x_31, x_3, x_4, x_5, x_6, x_32);
-if (lean_obj_tag(x_33) == 0)
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_34 = lean_ctor_get(x_33, 0);
-lean_inc(x_34);
-x_35 = lean_ctor_get(x_33, 1);
-lean_inc(x_35);
-if (lean_is_exclusive(x_33)) {
- lean_ctor_release(x_33, 0);
- lean_ctor_release(x_33, 1);
- x_36 = x_33;
-} else {
- lean_dec_ref(x_33);
- x_36 = lean_box(0);
-}
-x_37 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_37, 0, x_34);
-if (lean_is_scalar(x_36)) {
- x_38 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_38 = x_36;
-}
-lean_ctor_set(x_38, 0, x_37);
-lean_ctor_set(x_38, 1, x_35);
-return x_38;
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_39 = lean_ctor_get(x_33, 0);
-lean_inc(x_39);
-x_40 = lean_ctor_get(x_33, 1);
-lean_inc(x_40);
-if (lean_is_exclusive(x_33)) {
- lean_ctor_release(x_33, 0);
- lean_ctor_release(x_33, 1);
- x_41 = x_33;
-} else {
- lean_dec_ref(x_33);
- x_41 = lean_box(0);
-}
-if (lean_is_scalar(x_41)) {
- x_42 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_42 = x_41;
-}
-lean_ctor_set(x_42, 0, x_39);
-lean_ctor_set(x_42, 1, x_40);
-return x_42;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_43 = lean_ctor_get(x_30, 0);
-lean_inc(x_43);
-x_44 = lean_ctor_get(x_30, 1);
-lean_inc(x_44);
-if (lean_is_exclusive(x_30)) {
- lean_ctor_release(x_30, 0);
- lean_ctor_release(x_30, 1);
- x_45 = x_30;
-} else {
- lean_dec_ref(x_30);
- x_45 = lean_box(0);
-}
-if (lean_is_scalar(x_45)) {
- x_46 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_46 = x_45;
-}
-lean_ctor_set(x_46, 0, x_43);
-lean_ctor_set(x_46, 1, x_44);
-return x_46;
-}
-}
-}
-}
-}
-static lean_object* _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___closed__1() {
+static lean_object* _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -12346,47 +12123,160 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___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) {
 _start:
 {
-if (lean_obj_tag(x_1) == 0)
+lean_object* x_8; 
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+x_8 = l_Lean_Meta_inferType(x_1, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_8) == 0)
 {
-lean_object* x_8; lean_object* x_9; 
-x_8 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___closed__1;
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_8);
-lean_ctor_set(x_9, 1, x_7);
-return x_9;
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_9 = lean_ctor_get(x_8, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+lean_dec(x_8);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+x_11 = l_Lean_Meta_instantiateMVars(x_9, x_3, x_4, x_5, x_6, x_10);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_11, 1);
+lean_inc(x_13);
+lean_dec(x_11);
+x_14 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames(x_12, x_3, x_4, x_5, x_6, x_13);
+if (lean_obj_tag(x_14) == 0)
+{
+uint8_t x_15; 
+x_15 = !lean_is_exclusive(x_14);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; 
+x_16 = lean_ctor_get(x_14, 0);
+x_17 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_17, 0, x_16);
+lean_ctor_set(x_14, 0, x_17);
+return x_14;
 }
 else
 {
-uint8_t x_10; 
-x_10 = !lean_is_exclusive(x_1);
-if (x_10 == 0)
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = lean_ctor_get(x_14, 0);
+x_19 = lean_ctor_get(x_14, 1);
+lean_inc(x_19);
+lean_inc(x_18);
+lean_dec(x_14);
+x_20 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_20, 0, x_18);
+x_21 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_21, 0, x_20);
+lean_ctor_set(x_21, 1, x_19);
+return x_21;
+}
+}
+else
 {
-lean_object* x_11; 
-x_11 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_11, 0, x_1);
-lean_ctor_set(x_11, 1, x_7);
+uint8_t x_22; 
+x_22 = !lean_is_exclusive(x_14);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_14, 0);
+lean_dec(x_23);
+x_24 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1;
+lean_ctor_set_tag(x_14, 0);
+lean_ctor_set(x_14, 0, x_24);
+return x_14;
+}
+else
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = lean_ctor_get(x_14, 1);
+lean_inc(x_25);
+lean_dec(x_14);
+x_26 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1;
+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_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_28 = !lean_is_exclusive(x_11);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; 
+x_29 = lean_ctor_get(x_11, 0);
+lean_dec(x_29);
+x_30 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1;
+lean_ctor_set_tag(x_11, 0);
+lean_ctor_set(x_11, 0, x_30);
 return x_11;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_12 = lean_ctor_get(x_1, 0);
-lean_inc(x_12);
-lean_dec(x_1);
-x_13 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_13, 0, x_12);
-x_14 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_14, 0, x_13);
-lean_ctor_set(x_14, 1, x_7);
-return x_14;
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_31 = lean_ctor_get(x_11, 1);
+lean_inc(x_31);
+lean_dec(x_11);
+x_32 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1;
+x_33 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_33, 0, x_32);
+lean_ctor_set(x_33, 1, x_31);
+return x_33;
+}
+}
+}
+else
+{
+uint8_t x_34; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_34 = !lean_is_exclusive(x_8);
+if (x_34 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = lean_ctor_get(x_8, 0);
+lean_dec(x_35);
+x_36 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1;
+lean_ctor_set_tag(x_8, 0);
+lean_ctor_set(x_8, 0, x_36);
+return x_8;
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_37 = lean_ctor_get(x_8, 1);
+lean_inc(x_37);
+lean_dec(x_8);
+x_38 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1;
+x_39 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_39, 0, x_38);
+lean_ctor_set(x_39, 1, x_37);
+return x_39;
 }
 }
 }
 }
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -12415,34 +12305,10 @@ return x_12;
 }
 }
 }
-static lean_object* _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Info_fmtHover_x3f___lambda__1___boxed), 7, 0);
-return x_1;
-}
-}
-static lean_object* _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__2() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___boxed), 7, 0);
-return x_1;
-}
-}
-static lean_object* _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__3() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___boxed), 7, 0);
-return x_1;
-}
-}
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
 lean_inc(x_1);
@@ -12454,30 +12320,16 @@ lean_closure_set(x_6, 2, x_3);
 x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
 lean_dec(x_2);
-x_8 = lean_alloc_closure((void*)(l_Lean_Meta_inferType), 6, 1);
+x_8 = lean_alloc_closure((void*)(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___boxed), 7, 1);
 lean_closure_set(x_8, 0, x_7);
-x_9 = lean_alloc_closure((void*)(l_StateRefT_x27_lift___rarg___boxed), 2, 1);
-lean_closure_set(x_9, 0, x_8);
-x_10 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__1;
-x_11 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___spec__1___rarg), 8, 2);
-lean_closure_set(x_11, 0, x_9);
-lean_closure_set(x_11, 1, x_10);
-x_12 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__2;
-x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___spec__1___rarg), 8, 2);
-lean_closure_set(x_13, 0, x_11);
-lean_closure_set(x_13, 1, x_12);
-x_14 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__3;
-x_15 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___spec__1___rarg), 8, 2);
-lean_closure_set(x_15, 0, x_13);
-lean_closure_set(x_15, 1, x_14);
-x_16 = lean_alloc_closure((void*)(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__5), 8, 1);
-lean_closure_set(x_16, 0, x_6);
-x_17 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___spec__1___rarg), 8, 2);
-lean_closure_set(x_17, 0, x_15);
-lean_closure_set(x_17, 1, x_16);
-x_18 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_runM(x_1, x_5, x_17, x_4);
+x_9 = lean_alloc_closure((void*)(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4), 8, 1);
+lean_closure_set(x_9, 0, x_6);
+x_10 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___spec__1___rarg), 8, 2);
+lean_closure_set(x_10, 0, x_8);
+lean_closure_set(x_10, 1, x_9);
+x_11 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_runM(x_1, x_5, x_10, x_4);
 lean_dec(x_1);
-return x_18;
+return x_11;
 }
 }
 lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
@@ -12500,19 +12352,6 @@ lean_dec(x_2);
 return x_8;
 }
 }
-lean_object* l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; 
-x_8 = l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4(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_2);
-return x_8;
-}
-}
 static lean_object* _init_l_Std_RBNode_fold___at___private_Lean_Server_Completion_0__Lean_Server_Completion_optionCompletion___spec__1___closed__1() {
 _start:
 {
@@ -13930,14 +13769,8 @@ l_List_forIn_loop___at___private_Lean_Server_Completion_0__Lean_Server_Completio
 lean_mark_persistent(l_List_forIn_loop___at___private_Lean_Server_Completion_0__Lean_Server_Completion_idCompletionCore___spec__18___closed__1);
 l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames_visit___lambda__2___closed__1 = _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames_visit___lambda__2___closed__1();
 lean_mark_persistent(l___private_Lean_Server_Completion_0__Lean_Server_Completion_getDotCompletionTypeNames_visit___lambda__2___closed__1);
-l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___closed__1 = _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___closed__1();
-lean_mark_persistent(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__4___closed__1);
-l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__1 = _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__1();
-lean_mark_persistent(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__1);
-l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__2 = _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__2();
-lean_mark_persistent(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__2);
-l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__3 = _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__3();
-lean_mark_persistent(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___closed__3);
+l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1 = _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1();
+lean_mark_persistent(l___private_Lean_Server_Completion_0__Lean_Server_Completion_dotCompletion___lambda__3___closed__1);
 l_Std_RBNode_fold___at___private_Lean_Server_Completion_0__Lean_Server_Completion_optionCompletion___spec__1___closed__1 = _init_l_Std_RBNode_fold___at___private_Lean_Server_Completion_0__Lean_Server_Completion_optionCompletion___spec__1___closed__1();
 lean_mark_persistent(l_Std_RBNode_fold___at___private_Lean_Server_Completion_0__Lean_Server_Completion_optionCompletion___spec__1___closed__1);
 l___private_Lean_Server_Completion_0__Lean_Server_Completion_optionCompletion___closed__1 = _init_l___private_Lean_Server_Completion_0__Lean_Server_Completion_optionCompletion___closed__1();
diff --git a/stage0/stdlib/Lean/Server/FileWorker.c b/stage0/stdlib/Lean/Server/FileWorker.c
index 74c9d7e402..d2cae6abe0 100644
--- a/stage0/stdlib/Lean/Server/FileWorker.c
+++ b/stage0/stdlib/Lean/Server/FileWorker.c
@@ -45,6 +45,7 @@ lean_object* l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__2;
 lean_object* l_Lean_Server_FileWorker_handleRequest_match__2(lean_object*);
 lean_object* lean_io_prim_handle_get_line(lean_object*, lean_object*);
 lean_object* l___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_fromJsonDidOpenTextDocumentParams____x40_Lean_Data_Lsp_TextSync___hyg_100_(lean_object*);
+lean_object* l_System_FilePath_join(lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleHover___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_RequestError_fileChanged___closed__2;
 lean_object* l___private_Lean_Server_FileWorker_0__Lean_Server_FileWorker_logSnapContent___closed__1;
@@ -57,7 +58,7 @@ extern lean_object* l_Char_quote___closed__1;
 lean_object* l_Std_RBNode_erase___at_Lean_Server_FileWorker_handleCancelRequest___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_parseParams___at_Lean_Server_FileWorker_handleRequest___spec__5___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleDocumentSymbol_sectionLikeToDocumentSymbols___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Server_FileWorker_compileHeader___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Server_FileWorker_compileHeader___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getOptional_x3f(lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleDocumentSymbol_toDocumentSymbols___lambda__2___closed__3;
@@ -97,7 +98,6 @@ lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 extern lean_object* l_Lean_Lsp_Ipc_collectDiagnostics___closed__1;
 extern lean_object* l_Lean_JsonRpc_instToJsonErrorCode___closed__28;
 extern lean_object* l_Lean_identKind___closed__2;
-extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__2;
 extern lean_object* l_Lean_JsonRpc_instToJsonMessage___closed__6;
 lean_object* l_Lean_Server_FileWorker_handleDocumentHighlight_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleHover___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -242,6 +242,7 @@ extern lean_object* l_Lean_Elab_Info_fmtHover_x3f___lambda__2___closed__1;
 extern lean_object* l_Lean_maxRecDepth;
 lean_object* l_Lean_Server_FileWorker_compileHeader(lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_bind_task(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_pathExists(lean_object*, lean_object*);
 uint8_t l_Lean_Server_FileWorker_handleWaitForDiagnostics___lambda__1(lean_object*);
 lean_object* l_List_mapM___at_Lean_Server_FileWorker_handlePlainGoal___spec__5___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleRequest_match__2___rarg___closed__9;
@@ -252,6 +253,7 @@ lean_object* l_Lean_Server_FileWorker_handleRequest_match__2___rarg___closed__8;
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__7;
 lean_object* l_Lean_Elab_InfoTree_deepestNodes___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_updateDocument_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Syntax_formatStxAux___closed__3;
 lean_object* l_Lean_Server_FileWorker_initAndRunWorker_match__3___rarg(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_298____closed__2;
 lean_object* l_Lean_Server_FileWorker_handleNotification___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -282,6 +284,7 @@ uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_mainLoop___closed__1;
 lean_object* l_Lean_Server_FileWorker_initAndRunWorker_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleCompletion___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
 lean_object* l_Lean_Elab_InfoTree_goalsAt_x3f(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleCancelRequest___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Command_initialize___elambda__1___closed__1;
@@ -404,6 +407,7 @@ lean_object* l_Lean_Server_FileWorker_handleDocumentSymbol_toDocumentSymbols___l
 lean_object* l_IO_AsyncList_waitAll___at_Lean_Server_FileWorker_handleSemanticTokens___spec__1___closed__1;
 lean_object* l_Lean_Server_FileWorker_handleRequest___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializeParams___spec__2(lean_object*, lean_object*);
+lean_object* l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__7;
 lean_object* l_Lean_SearchPath_findWithExt(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_parseParams(lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleRequest(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -494,6 +498,7 @@ lean_object* l_Lean_Server_FileWorker_handleCompletion___closed__2;
 lean_object* l_Lean_Server_publishDiagnostics(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_leanpkgSetupSearchPath_match__1(lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializeParams___spec__5(lean_object*, lean_object*);
+extern lean_object* l_System_FilePath_exeExtension;
 lean_object* l_Lean_Server_FileWorker_handleDocumentSymbol_match__1(lean_object*);
 extern lean_object* l_Lean_Parser_Term_doReturn___elambda__1___closed__2;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleCompletion___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -536,7 +541,6 @@ lean_object* l_Lean_Server_FileWorker_handleSemanticTokens_highlightKeyword_matc
 lean_object* l_Lean_Server_FileWorker_parseParams___at_Lean_Server_FileWorker_handleRequest___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__2;
 lean_object* l_Lean_Syntax_getPos_x3f(lean_object*, uint8_t);
-lean_object* lean_io_file_exists(lean_object*, lean_object*);
 lean_object* lean_mk_empty_environment(uint32_t, lean_object*);
 lean_object* l_Lean_Server_FileWorker_parseParams___at_Lean_Server_FileWorker_handleRequest___spec__14___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_instCoeErrorElabTaskError(lean_object*);
@@ -671,7 +675,6 @@ uint8_t l_Lean_Syntax_isNone(lean_object*);
 extern lean_object* l_IO_FS_Stream_readLspRequestAs___closed__1;
 lean_object* l_Lean_Meta_inferType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleDefinition_match__5___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_parseSearchPath(lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleDocumentSymbol(lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleSemanticTokens_highlightId_match__4(lean_object*);
 lean_object* l_EStateM_instInhabitedEStateM___rarg(lean_object*, lean_object*);
@@ -692,6 +695,7 @@ uint8_t l_Lean_Server_FileWorker_updateDocument___lambda__1(lean_object*, lean_o
 lean_object* l_Lean_Server_FileWorker_noHighlightKinds;
 lean_object* l_Lean_Server_FileWorker_compileHeader_match__3___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Server_foldDocumentChanges(lean_object*, lean_object*);
+extern lean_object* l_Lean_getBuiltinSearchPath___lambda__1___closed__1;
 lean_object* l_Lean_Server_FileWorker_handleHover___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instantiateMVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_TagDeclarationExtension_isTagged(lean_object*, lean_object*, lean_object*);
@@ -699,6 +703,7 @@ lean_object* l_IO_FS_Stream_withPrefix(lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_forIn___at_Lean_Server_FileWorker_handleCompletion___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_ppGoal___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_leanpkgSetupSearchPath_processStderr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_SearchPath_parse(lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_forInAux___at_Lean_Server_FileWorker_handleCompletion___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Util_Trace_0__Lean_addNode___rarg___lambda__1___closed__2;
@@ -741,6 +746,7 @@ lean_object* l_Lean_Server_FileWorker_handleSemanticTokens___lambda__2___closed_
 lean_object* l_Lean_Server_FileWorker_parseParams___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Info_pos_x3f(lean_object*);
 lean_object* l_Lean_Server_FileWorker_handleNotification_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_withExtension(lean_object*, lean_object*);
 lean_object* l_ReaderT_pure___at_Lean_Server_FileWorker_handleCompletion___spec__1(lean_object*);
 extern lean_object* l_IO_instInhabitedError;
 lean_object* l_Lean_Server_FileWorker_handleDocumentSymbol___rarg(lean_object*, lean_object*);
@@ -756,10 +762,10 @@ lean_object* l_Lean_Server_FileWorker_withWaitFindSnap_match__1___rarg(lean_obje
 lean_object* l_IO_mkRef___at_Lean_Server_FileWorker_CancelToken_new___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_mainLoop_match__2(lean_object*);
-extern lean_object* l_System_FilePath_exeSuffix;
 uint8_t l_List_isEmpty___rarg(lean_object*);
 lean_object* l_List_lengthAux___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_myMacro____x40_Init_NotationExtra___hyg_1094____closed__5;
+extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__1;
 lean_object* l_Lean_Server_FileWorker_handleWaitForDiagnostics_waitLoop___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__6(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_FileWorker_handlePlainGoal_match__3(lean_object*);
@@ -767,7 +773,6 @@ lean_object* l_Lean_Server_FileWorker_handleDocumentSymbol_toDocumentSymbols___c
 lean_object* l___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_fromJsonDidChangeTextDocumentParams____x40_Lean_Data_Lsp_TextSync___hyg_376_(lean_object*);
 lean_object* l_Lean_Server_FileWorker_handlePlainGoal___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_JsonRpc_instToJsonErrorCode___closed__12;
-lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2___closed__1;
 lean_object* l_Lean_Server_FileWorker_withWaitFindSnap___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___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* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___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_object*, lean_object*);
@@ -2858,401 +2863,420 @@ x_1 = lean_mk_string("unexpected output from `leanpkg print-paths`:\n");
 return x_1;
 }
 }
+static lean_object* _init_l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__7() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_instInhabitedParserDescr___closed__1;
+x_2 = l_System_SearchPath_parse(x_1);
+return x_2;
+}
+}
 lean_object* l_Lean_Server_FileWorker_leanpkgSetupSearchPath(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_6 = lean_box(0);
-x_7 = lean_array_get_size(x_3);
-x_8 = lean_usize_of_nat(x_7);
-lean_dec(x_7);
-x_9 = 0;
+lean_object* x_6; size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_6 = lean_array_get_size(x_3);
+x_7 = lean_usize_of_nat(x_6);
+lean_dec(x_6);
+x_8 = 0;
 lean_inc(x_3);
-x_10 = x_3;
-x_11 = l_Array_mapMUnsafe_map___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__1(x_8, x_9, x_10);
-x_12 = x_11;
-x_13 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__3;
-x_14 = l_Array_append___rarg(x_13, x_12);
-lean_dec(x_12);
-x_15 = lean_box(0);
-x_16 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__1;
-x_17 = l_Array_empty___closed__1;
+x_9 = x_3;
+x_10 = l_Array_mapMUnsafe_map___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__1(x_7, x_8, x_9);
+x_11 = x_10;
+x_12 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__3;
+x_13 = l_Array_append___rarg(x_12, x_11);
+lean_dec(x_11);
+x_14 = lean_box(0);
+x_15 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__1;
+x_16 = l_Array_empty___closed__1;
 lean_inc(x_1);
-x_18 = lean_alloc_ctor(0, 5, 0);
-lean_ctor_set(x_18, 0, x_16);
-lean_ctor_set(x_18, 1, x_1);
-lean_ctor_set(x_18, 2, x_14);
-lean_ctor_set(x_18, 3, x_15);
-lean_ctor_set(x_18, 4, x_17);
-x_19 = lean_io_process_spawn(x_18, x_5);
-if (lean_obj_tag(x_19) == 0)
+x_17 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_17, 0, x_15);
+lean_ctor_set(x_17, 1, x_1);
+lean_ctor_set(x_17, 2, x_13);
+lean_ctor_set(x_17, 3, x_14);
+lean_ctor_set(x_17, 4, x_16);
+x_18 = lean_io_process_spawn(x_17, x_5);
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_20 = lean_ctor_get(x_19, 0);
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-lean_dec(x_19);
-x_22 = l_Lean_instInhabitedParserDescr___closed__1;
-lean_inc(x_20);
-x_23 = lean_alloc_closure((void*)(l_Lean_Server_FileWorker_leanpkgSetupSearchPath_processStderr___boxed), 7, 6);
-lean_closure_set(x_23, 0, x_1);
-lean_closure_set(x_23, 1, x_2);
-lean_closure_set(x_23, 2, x_3);
-lean_closure_set(x_23, 3, x_4);
-lean_closure_set(x_23, 4, x_20);
-lean_closure_set(x_23, 5, x_22);
-x_24 = l_Task_Priority_dedicated;
-x_25 = lean_io_as_task(x_23, x_24, x_21);
-if (lean_obj_tag(x_25) == 0)
+lean_dec(x_18);
+x_21 = l_Lean_instInhabitedParserDescr___closed__1;
+lean_inc(x_19);
+x_22 = lean_alloc_closure((void*)(l_Lean_Server_FileWorker_leanpkgSetupSearchPath_processStderr___boxed), 7, 6);
+lean_closure_set(x_22, 0, x_1);
+lean_closure_set(x_22, 1, x_2);
+lean_closure_set(x_22, 2, x_3);
+lean_closure_set(x_22, 3, x_4);
+lean_closure_set(x_22, 4, x_19);
+lean_closure_set(x_22, 5, x_21);
+x_23 = l_Task_Priority_dedicated;
+x_24 = lean_io_as_task(x_22, x_23, x_20);
+if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_26 = lean_ctor_get(x_25, 0);
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_25 = lean_ctor_get(x_24, 0);
+lean_inc(x_25);
+x_26 = lean_ctor_get(x_24, 1);
 lean_inc(x_26);
-x_27 = lean_ctor_get(x_25, 1);
+lean_dec(x_24);
+x_27 = lean_ctor_get(x_19, 1);
 lean_inc(x_27);
-lean_dec(x_25);
-x_28 = lean_ctor_get(x_20, 1);
-lean_inc(x_28);
-x_29 = l_IO_FS_Handle_readToEnd_read___at_IO_Process_output___spec__1(x_28, x_22, x_27);
-lean_dec(x_28);
-if (lean_obj_tag(x_29) == 0)
+x_28 = l_IO_FS_Handle_readToEnd_read___at_IO_Process_output___spec__1(x_27, x_21, x_26);
+lean_dec(x_27);
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_30 = lean_ctor_get(x_29, 0);
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_29 = lean_ctor_get(x_28, 0);
+lean_inc(x_29);
+x_30 = lean_ctor_get(x_28, 1);
 lean_inc(x_30);
-x_31 = lean_ctor_get(x_29, 1);
-lean_inc(x_31);
+lean_dec(x_28);
+x_31 = l_String_trim(x_29);
 lean_dec(x_29);
-x_32 = l_String_trim(x_30);
-lean_dec(x_30);
-x_33 = lean_task_get_own(x_26);
-x_34 = l_IO_ofExcept___at_IO_Process_output___spec__3(x_33, x_31);
-if (lean_obj_tag(x_34) == 0)
+x_32 = lean_task_get_own(x_25);
+x_33 = l_IO_ofExcept___at_IO_Process_output___spec__3(x_32, x_30);
+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_33);
+x_36 = lean_io_process_child_wait(x_15, x_19, x_35);
+lean_dec(x_19);
+if (lean_obj_tag(x_36) == 0)
+{
+uint8_t x_37; 
+x_37 = !lean_is_exclusive(x_36);
+if (x_37 == 0)
+{
+lean_object* x_38; lean_object* x_39; uint32_t x_40; uint32_t x_41; uint8_t x_42; 
+x_38 = lean_ctor_get(x_36, 0);
+x_39 = lean_ctor_get(x_36, 1);
+x_40 = 0;
+x_41 = lean_unbox_uint32(x_38);
+lean_dec(x_38);
+x_42 = x_41 == x_40;
+if (x_42 == 0)
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_43 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__4;
+x_44 = lean_string_append(x_43, x_31);
+lean_dec(x_31);
+x_45 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_46 = lean_string_append(x_44, x_45);
+x_47 = lean_string_append(x_46, x_34);
 lean_dec(x_34);
-x_37 = lean_io_process_child_wait(x_16, x_20, x_36);
-lean_dec(x_20);
-if (lean_obj_tag(x_37) == 0)
-{
-uint8_t x_38; 
-x_38 = !lean_is_exclusive(x_37);
-if (x_38 == 0)
-{
-lean_object* x_39; lean_object* x_40; uint32_t x_41; uint32_t x_42; uint8_t x_43; 
-x_39 = lean_ctor_get(x_37, 0);
-x_40 = lean_ctor_get(x_37, 1);
-x_41 = 0;
-x_42 = lean_unbox_uint32(x_39);
-lean_dec(x_39);
-x_43 = x_42 == x_41;
-if (x_43 == 0)
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-x_44 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__4;
-x_45 = lean_string_append(x_44, x_32);
-lean_dec(x_32);
-x_46 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_47 = lean_string_append(x_45, x_46);
-x_48 = lean_string_append(x_47, x_35);
-lean_dec(x_35);
-x_49 = lean_string_append(x_48, x_22);
-x_50 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set_tag(x_37, 1);
-lean_ctor_set(x_37, 0, x_50);
-return x_37;
+x_48 = lean_string_append(x_47, x_21);
+x_49 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_49, 0, x_48);
+lean_ctor_set_tag(x_36, 1);
+lean_ctor_set(x_36, 0, x_49);
+return x_36;
 }
 else
 {
-lean_object* x_51; 
-x_51 = l_String_split___at_Lean_stringToMessageData___spec__1(x_32);
-if (lean_obj_tag(x_51) == 0)
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+x_50 = l_String_split___at_Lean_stringToMessageData___spec__1(x_31);
+x_51 = lean_unsigned_to_nat(0u);
+x_52 = l_List_lengthAux___rarg(x_50, x_51);
+x_53 = lean_unsigned_to_nat(2u);
+x_54 = lean_nat_sub(x_52, x_53);
+lean_dec(x_52);
+x_55 = l_List_drop___rarg(x_54, x_50);
+lean_dec(x_50);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-x_52 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_53 = lean_string_append(x_52, x_32);
-lean_dec(x_32);
-x_54 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_55 = lean_string_append(x_53, x_54);
-x_56 = lean_string_append(x_55, x_35);
-lean_dec(x_35);
-x_57 = lean_string_append(x_56, x_22);
-x_58 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set_tag(x_37, 1);
-lean_ctor_set(x_37, 0, x_58);
-return x_37;
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_56 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_57 = lean_string_append(x_56, x_31);
+lean_dec(x_31);
+x_58 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_59 = lean_string_append(x_57, x_58);
+x_60 = lean_string_append(x_59, x_34);
+lean_dec(x_34);
+x_61 = lean_string_append(x_60, x_21);
+x_62 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_62, 0, x_61);
+lean_ctor_set_tag(x_36, 1);
+lean_ctor_set(x_36, 0, x_62);
+return x_36;
 }
 else
 {
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_51, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_51, 1);
-lean_inc(x_60);
-lean_dec(x_51);
-x_61 = lean_string_dec_eq(x_59, x_22);
-if (x_61 == 0)
+lean_object* x_63; lean_object* x_64; uint8_t x_65; 
+x_63 = lean_ctor_get(x_55, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_55, 1);
+lean_inc(x_64);
+lean_dec(x_55);
+x_65 = lean_string_dec_eq(x_63, x_21);
+if (x_65 == 0)
 {
-if (lean_obj_tag(x_60) == 0)
+if (lean_obj_tag(x_64) == 0)
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-lean_dec(x_59);
-x_62 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_63 = lean_string_append(x_62, x_32);
-lean_dec(x_32);
-x_64 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_65 = lean_string_append(x_63, x_64);
-x_66 = lean_string_append(x_65, x_35);
-lean_dec(x_35);
-x_67 = lean_string_append(x_66, x_22);
-x_68 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_68, 0, x_67);
-lean_ctor_set_tag(x_37, 1);
-lean_ctor_set(x_37, 0, x_68);
-return x_37;
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+lean_dec(x_63);
+x_66 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_67 = lean_string_append(x_66, x_31);
+lean_dec(x_31);
+x_68 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_69 = lean_string_append(x_67, x_68);
+x_70 = lean_string_append(x_69, x_34);
+lean_dec(x_34);
+x_71 = lean_string_append(x_70, x_21);
+x_72 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_72, 0, x_71);
+lean_ctor_set_tag(x_36, 1);
+lean_ctor_set(x_36, 0, x_72);
+return x_36;
 }
 else
 {
-lean_object* x_69; 
-x_69 = lean_ctor_get(x_60, 1);
-lean_inc(x_69);
-if (lean_obj_tag(x_69) == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-lean_free_object(x_37);
-lean_dec(x_35);
-lean_dec(x_32);
-x_70 = lean_ctor_get(x_60, 0);
-lean_inc(x_70);
-lean_dec(x_60);
-x_71 = l_Lean_getBuiltinSearchPath(x_40);
-if (lean_obj_tag(x_71) == 0)
-{
-lean_object* x_72; lean_object* x_73; lean_object* x_74; 
-x_72 = lean_ctor_get(x_71, 0);
-lean_inc(x_72);
-x_73 = lean_ctor_get(x_71, 1);
+lean_object* x_73; 
+x_73 = lean_ctor_get(x_64, 1);
 lean_inc(x_73);
-lean_dec(x_71);
-x_74 = l_Lean_addSearchPathFromEnv(x_72, x_73);
-if (lean_obj_tag(x_74) == 0)
+if (lean_obj_tag(x_73) == 0)
 {
-lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-x_75 = lean_ctor_get(x_74, 0);
-lean_inc(x_75);
-x_76 = lean_ctor_get(x_74, 1);
+lean_object* x_74; lean_object* x_75; 
+lean_free_object(x_36);
+lean_dec(x_34);
+lean_dec(x_31);
+x_74 = lean_ctor_get(x_64, 0);
+lean_inc(x_74);
+lean_dec(x_64);
+x_75 = l_Lean_getBuiltinSearchPath(x_39);
+if (lean_obj_tag(x_75) == 0)
+{
+lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+x_76 = lean_ctor_get(x_75, 0);
 lean_inc(x_76);
-lean_dec(x_74);
-x_77 = l_Lean_parseSearchPath(x_59, x_75);
-lean_dec(x_59);
-x_78 = l_Lean_searchPathRef;
-x_79 = lean_st_ref_set(x_78, x_77, x_76);
-x_80 = lean_ctor_get(x_79, 1);
+x_77 = lean_ctor_get(x_75, 1);
+lean_inc(x_77);
+lean_dec(x_75);
+x_78 = l_Lean_addSearchPathFromEnv(x_76, x_77);
+if (lean_obj_tag(x_78) == 0)
+{
+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; 
+x_79 = lean_ctor_get(x_78, 0);
+lean_inc(x_79);
+x_80 = lean_ctor_get(x_78, 1);
 lean_inc(x_80);
-lean_dec(x_79);
-x_81 = l_Lean_parseSearchPath(x_70, x_6);
-lean_dec(x_70);
-x_82 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_81, x_80);
-return x_82;
-}
-else
-{
-uint8_t x_83; 
-lean_dec(x_70);
-lean_dec(x_59);
-x_83 = !lean_is_exclusive(x_74);
-if (x_83 == 0)
-{
-return x_74;
-}
-else
-{
-lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-x_84 = lean_ctor_get(x_74, 0);
-x_85 = lean_ctor_get(x_74, 1);
+lean_dec(x_78);
+x_81 = l_System_SearchPath_parse(x_63);
+lean_dec(x_63);
+x_82 = l_List_append___rarg(x_81, x_79);
+x_83 = l_Lean_searchPathRef;
+x_84 = lean_st_ref_set(x_83, x_82, x_80);
+x_85 = lean_ctor_get(x_84, 1);
 lean_inc(x_85);
-lean_inc(x_84);
+lean_dec(x_84);
+x_86 = l_System_SearchPath_parse(x_74);
 lean_dec(x_74);
-x_86 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_86, 0, x_84);
-lean_ctor_set(x_86, 1, x_85);
-return x_86;
-}
-}
+x_87 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_86, x_85);
+return x_87;
 }
 else
 {
-uint8_t x_87; 
-lean_dec(x_70);
-lean_dec(x_59);
-x_87 = !lean_is_exclusive(x_71);
-if (x_87 == 0)
+uint8_t x_88; 
+lean_dec(x_74);
+lean_dec(x_63);
+x_88 = !lean_is_exclusive(x_78);
+if (x_88 == 0)
 {
-return x_71;
+return x_78;
 }
 else
 {
-lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-x_88 = lean_ctor_get(x_71, 0);
-x_89 = lean_ctor_get(x_71, 1);
+lean_object* x_89; lean_object* x_90; lean_object* x_91; 
+x_89 = lean_ctor_get(x_78, 0);
+x_90 = lean_ctor_get(x_78, 1);
+lean_inc(x_90);
 lean_inc(x_89);
-lean_inc(x_88);
-lean_dec(x_71);
-x_90 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_90, 0, x_88);
-lean_ctor_set(x_90, 1, x_89);
-return x_90;
+lean_dec(x_78);
+x_91 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_91, 0, x_89);
+lean_ctor_set(x_91, 1, x_90);
+return x_91;
 }
 }
 }
 else
 {
-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_dec(x_69);
-lean_dec(x_60);
-lean_dec(x_59);
-x_91 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_92 = lean_string_append(x_91, x_32);
-lean_dec(x_32);
-x_93 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_94 = lean_string_append(x_92, x_93);
-x_95 = lean_string_append(x_94, x_35);
-lean_dec(x_35);
-x_96 = lean_string_append(x_95, x_22);
-x_97 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_97, 0, x_96);
-lean_ctor_set_tag(x_37, 1);
-lean_ctor_set(x_37, 0, x_97);
-return x_37;
+uint8_t x_92; 
+lean_dec(x_74);
+lean_dec(x_63);
+x_92 = !lean_is_exclusive(x_75);
+if (x_92 == 0)
+{
+return x_75;
+}
+else
+{
+lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+x_93 = lean_ctor_get(x_75, 0);
+x_94 = lean_ctor_get(x_75, 1);
+lean_inc(x_94);
+lean_inc(x_93);
+lean_dec(x_75);
+x_95 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_95, 0, x_93);
+lean_ctor_set(x_95, 1, x_94);
+return x_95;
 }
 }
 }
 else
 {
-lean_dec(x_59);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_dec(x_35);
-lean_dec(x_32);
-lean_ctor_set(x_37, 0, x_6);
-return x_37;
+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_dec(x_73);
+lean_dec(x_64);
+lean_dec(x_63);
+x_96 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_97 = lean_string_append(x_96, x_31);
+lean_dec(x_31);
+x_98 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_99 = lean_string_append(x_97, x_98);
+x_100 = lean_string_append(x_99, x_34);
+lean_dec(x_34);
+x_101 = lean_string_append(x_100, x_21);
+x_102 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_102, 0, x_101);
+lean_ctor_set_tag(x_36, 1);
+lean_ctor_set(x_36, 0, x_102);
+return x_36;
+}
+}
 }
 else
 {
-lean_object* x_98; 
-x_98 = lean_ctor_get(x_60, 1);
-lean_inc(x_98);
-if (lean_obj_tag(x_98) == 0)
+lean_dec(x_63);
+if (lean_obj_tag(x_64) == 0)
 {
-lean_object* x_99; lean_object* x_100; 
-lean_free_object(x_37);
-lean_dec(x_35);
-lean_dec(x_32);
-x_99 = lean_ctor_get(x_60, 0);
-lean_inc(x_99);
-lean_dec(x_60);
-x_100 = l_Lean_getBuiltinSearchPath(x_40);
-if (lean_obj_tag(x_100) == 0)
+lean_object* x_103; 
+lean_dec(x_34);
+lean_dec(x_31);
+x_103 = lean_box(0);
+lean_ctor_set(x_36, 0, x_103);
+return x_36;
+}
+else
 {
-lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-x_101 = lean_ctor_get(x_100, 0);
-lean_inc(x_101);
-x_102 = lean_ctor_get(x_100, 1);
-lean_inc(x_102);
-lean_dec(x_100);
-x_103 = l_Lean_addSearchPathFromEnv(x_101, x_102);
-if (lean_obj_tag(x_103) == 0)
-{
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; 
-x_104 = lean_ctor_get(x_103, 0);
+lean_object* x_104; 
+x_104 = lean_ctor_get(x_64, 1);
 lean_inc(x_104);
-x_105 = lean_ctor_get(x_103, 1);
+if (lean_obj_tag(x_104) == 0)
+{
+lean_object* x_105; lean_object* x_106; 
+lean_free_object(x_36);
+lean_dec(x_34);
+lean_dec(x_31);
+x_105 = lean_ctor_get(x_64, 0);
 lean_inc(x_105);
-lean_dec(x_103);
-x_106 = l_Lean_parseSearchPath(x_22, x_104);
-x_107 = l_Lean_searchPathRef;
-x_108 = lean_st_ref_set(x_107, x_106, x_105);
-x_109 = lean_ctor_get(x_108, 1);
-lean_inc(x_109);
-lean_dec(x_108);
-x_110 = l_Lean_parseSearchPath(x_99, x_6);
-lean_dec(x_99);
-x_111 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_110, x_109);
-return x_111;
+lean_dec(x_64);
+x_106 = l_Lean_getBuiltinSearchPath(x_39);
+if (lean_obj_tag(x_106) == 0)
+{
+lean_object* x_107; lean_object* x_108; lean_object* x_109; 
+x_107 = lean_ctor_get(x_106, 0);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_106, 1);
+lean_inc(x_108);
+lean_dec(x_106);
+x_109 = l_Lean_addSearchPathFromEnv(x_107, x_108);
+if (lean_obj_tag(x_109) == 0)
+{
+lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
+x_110 = lean_ctor_get(x_109, 0);
+lean_inc(x_110);
+x_111 = lean_ctor_get(x_109, 1);
+lean_inc(x_111);
+lean_dec(x_109);
+x_112 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__7;
+x_113 = l_List_append___rarg(x_112, x_110);
+x_114 = l_Lean_searchPathRef;
+x_115 = lean_st_ref_set(x_114, x_113, x_111);
+x_116 = lean_ctor_get(x_115, 1);
+lean_inc(x_116);
+lean_dec(x_115);
+x_117 = l_System_SearchPath_parse(x_105);
+lean_dec(x_105);
+x_118 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_117, x_116);
+return x_118;
 }
 else
 {
-uint8_t x_112; 
-lean_dec(x_99);
-x_112 = !lean_is_exclusive(x_103);
-if (x_112 == 0)
+uint8_t x_119; 
+lean_dec(x_105);
+x_119 = !lean_is_exclusive(x_109);
+if (x_119 == 0)
 {
-return x_103;
+return x_109;
 }
 else
 {
-lean_object* x_113; lean_object* x_114; lean_object* x_115; 
-x_113 = lean_ctor_get(x_103, 0);
-x_114 = lean_ctor_get(x_103, 1);
-lean_inc(x_114);
-lean_inc(x_113);
-lean_dec(x_103);
-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;
+lean_object* x_120; lean_object* x_121; lean_object* x_122; 
+x_120 = lean_ctor_get(x_109, 0);
+x_121 = lean_ctor_get(x_109, 1);
+lean_inc(x_121);
+lean_inc(x_120);
+lean_dec(x_109);
+x_122 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_122, 0, x_120);
+lean_ctor_set(x_122, 1, x_121);
+return x_122;
 }
 }
 }
 else
 {
-uint8_t x_116; 
-lean_dec(x_99);
-x_116 = !lean_is_exclusive(x_100);
-if (x_116 == 0)
+uint8_t x_123; 
+lean_dec(x_105);
+x_123 = !lean_is_exclusive(x_106);
+if (x_123 == 0)
 {
-return x_100;
+return x_106;
 }
 else
 {
-lean_object* x_117; lean_object* x_118; lean_object* x_119; 
-x_117 = lean_ctor_get(x_100, 0);
-x_118 = lean_ctor_get(x_100, 1);
-lean_inc(x_118);
-lean_inc(x_117);
-lean_dec(x_100);
-x_119 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_119, 0, x_117);
-lean_ctor_set(x_119, 1, x_118);
-return x_119;
+lean_object* x_124; lean_object* x_125; lean_object* x_126; 
+x_124 = lean_ctor_get(x_106, 0);
+x_125 = lean_ctor_get(x_106, 1);
+lean_inc(x_125);
+lean_inc(x_124);
+lean_dec(x_106);
+x_126 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_126, 0, x_124);
+lean_ctor_set(x_126, 1, x_125);
+return x_126;
 }
 }
 }
 else
 {
-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_dec(x_98);
-lean_dec(x_60);
-x_120 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_121 = lean_string_append(x_120, x_32);
-lean_dec(x_32);
-x_122 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_123 = lean_string_append(x_121, x_122);
-x_124 = lean_string_append(x_123, x_35);
-lean_dec(x_35);
-x_125 = lean_string_append(x_124, x_22);
-x_126 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_126, 0, x_125);
-lean_ctor_set_tag(x_37, 1);
-lean_ctor_set(x_37, 0, x_126);
-return x_37;
+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_dec(x_104);
+lean_dec(x_64);
+x_127 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_128 = lean_string_append(x_127, x_31);
+lean_dec(x_31);
+x_129 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_130 = lean_string_append(x_128, x_129);
+x_131 = lean_string_append(x_130, x_34);
+lean_dec(x_34);
+x_132 = lean_string_append(x_131, x_21);
+x_133 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_133, 0, x_132);
+lean_ctor_set_tag(x_36, 1);
+lean_ctor_set(x_36, 0, x_133);
+return x_36;
 }
 }
 }
@@ -3261,462 +3285,472 @@ return x_37;
 }
 else
 {
-lean_object* x_127; lean_object* x_128; uint32_t x_129; uint32_t x_130; uint8_t x_131; 
-x_127 = lean_ctor_get(x_37, 0);
-x_128 = lean_ctor_get(x_37, 1);
-lean_inc(x_128);
-lean_inc(x_127);
-lean_dec(x_37);
-x_129 = 0;
-x_130 = lean_unbox_uint32(x_127);
-lean_dec(x_127);
-x_131 = x_130 == x_129;
-if (x_131 == 0)
+lean_object* x_134; lean_object* x_135; uint32_t x_136; uint32_t x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_36, 0);
+x_135 = lean_ctor_get(x_36, 1);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_36);
+x_136 = 0;
+x_137 = lean_unbox_uint32(x_134);
+lean_dec(x_134);
+x_138 = x_137 == x_136;
+if (x_138 == 0)
 {
-lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; 
-x_132 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__4;
-x_133 = lean_string_append(x_132, x_32);
-lean_dec(x_32);
-x_134 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_135 = lean_string_append(x_133, x_134);
-x_136 = lean_string_append(x_135, x_35);
-lean_dec(x_35);
-x_137 = lean_string_append(x_136, x_22);
-x_138 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_138, 0, x_137);
-x_139 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_139, 0, x_138);
-lean_ctor_set(x_139, 1, x_128);
-return x_139;
+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; 
+x_139 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__4;
+x_140 = lean_string_append(x_139, x_31);
+lean_dec(x_31);
+x_141 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_142 = lean_string_append(x_140, x_141);
+x_143 = lean_string_append(x_142, x_34);
+lean_dec(x_34);
+x_144 = lean_string_append(x_143, x_21);
+x_145 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_145, 0, x_144);
+x_146 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_146, 0, x_145);
+lean_ctor_set(x_146, 1, x_135);
+return x_146;
 }
 else
 {
-lean_object* x_140; 
-x_140 = l_String_split___at_Lean_stringToMessageData___spec__1(x_32);
-if (lean_obj_tag(x_140) == 0)
-{
-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; 
-x_141 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_142 = lean_string_append(x_141, x_32);
-lean_dec(x_32);
-x_143 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_144 = lean_string_append(x_142, x_143);
-x_145 = lean_string_append(x_144, x_35);
-lean_dec(x_35);
-x_146 = lean_string_append(x_145, x_22);
-x_147 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_147, 0, x_146);
-x_148 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_148, 0, x_147);
-lean_ctor_set(x_148, 1, x_128);
-return x_148;
-}
-else
-{
-lean_object* x_149; lean_object* x_150; uint8_t x_151; 
-x_149 = lean_ctor_get(x_140, 0);
-lean_inc(x_149);
-x_150 = lean_ctor_get(x_140, 1);
-lean_inc(x_150);
-lean_dec(x_140);
-x_151 = lean_string_dec_eq(x_149, x_22);
-if (x_151 == 0)
-{
-if (lean_obj_tag(x_150) == 0)
-{
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; 
+lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
+x_147 = l_String_split___at_Lean_stringToMessageData___spec__1(x_31);
+x_148 = lean_unsigned_to_nat(0u);
+x_149 = l_List_lengthAux___rarg(x_147, x_148);
+x_150 = lean_unsigned_to_nat(2u);
+x_151 = lean_nat_sub(x_149, x_150);
 lean_dec(x_149);
-x_152 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_153 = lean_string_append(x_152, x_32);
-lean_dec(x_32);
-x_154 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_155 = lean_string_append(x_153, x_154);
-x_156 = lean_string_append(x_155, x_35);
-lean_dec(x_35);
-x_157 = lean_string_append(x_156, x_22);
-x_158 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_158, 0, x_157);
-x_159 = lean_alloc_ctor(1, 2, 0);
+x_152 = l_List_drop___rarg(x_151, x_147);
+lean_dec(x_147);
+if (lean_obj_tag(x_152) == 0)
+{
+lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; 
+x_153 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_154 = lean_string_append(x_153, x_31);
+lean_dec(x_31);
+x_155 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_156 = lean_string_append(x_154, x_155);
+x_157 = lean_string_append(x_156, x_34);
+lean_dec(x_34);
+x_158 = lean_string_append(x_157, x_21);
+x_159 = lean_alloc_ctor(18, 1, 0);
 lean_ctor_set(x_159, 0, x_158);
-lean_ctor_set(x_159, 1, x_128);
-return x_159;
+x_160 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_160, 0, x_159);
+lean_ctor_set(x_160, 1, x_135);
+return x_160;
 }
 else
 {
-lean_object* x_160; 
-x_160 = lean_ctor_get(x_150, 1);
-lean_inc(x_160);
-if (lean_obj_tag(x_160) == 0)
-{
-lean_object* x_161; lean_object* x_162; 
-lean_dec(x_35);
-lean_dec(x_32);
-x_161 = lean_ctor_get(x_150, 0);
+lean_object* x_161; lean_object* x_162; uint8_t x_163; 
+x_161 = lean_ctor_get(x_152, 0);
 lean_inc(x_161);
-lean_dec(x_150);
-x_162 = l_Lean_getBuiltinSearchPath(x_128);
+x_162 = lean_ctor_get(x_152, 1);
+lean_inc(x_162);
+lean_dec(x_152);
+x_163 = lean_string_dec_eq(x_161, x_21);
+if (x_163 == 0)
+{
 if (lean_obj_tag(x_162) == 0)
 {
-lean_object* x_163; lean_object* x_164; lean_object* x_165; 
-x_163 = lean_ctor_get(x_162, 0);
-lean_inc(x_163);
-x_164 = lean_ctor_get(x_162, 1);
-lean_inc(x_164);
+lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; 
+lean_dec(x_161);
+x_164 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_165 = lean_string_append(x_164, x_31);
+lean_dec(x_31);
+x_166 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_167 = lean_string_append(x_165, x_166);
+x_168 = lean_string_append(x_167, x_34);
+lean_dec(x_34);
+x_169 = lean_string_append(x_168, x_21);
+x_170 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_170, 0, x_169);
+x_171 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_171, 0, x_170);
+lean_ctor_set(x_171, 1, x_135);
+return x_171;
+}
+else
+{
+lean_object* x_172; 
+x_172 = lean_ctor_get(x_162, 1);
+lean_inc(x_172);
+if (lean_obj_tag(x_172) == 0)
+{
+lean_object* x_173; lean_object* x_174; 
+lean_dec(x_34);
+lean_dec(x_31);
+x_173 = lean_ctor_get(x_162, 0);
+lean_inc(x_173);
 lean_dec(x_162);
-x_165 = l_Lean_addSearchPathFromEnv(x_163, x_164);
-if (lean_obj_tag(x_165) == 0)
+x_174 = l_Lean_getBuiltinSearchPath(x_135);
+if (lean_obj_tag(x_174) == 0)
 {
-lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; 
-x_166 = lean_ctor_get(x_165, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_165, 1);
-lean_inc(x_167);
-lean_dec(x_165);
-x_168 = l_Lean_parseSearchPath(x_149, x_166);
-lean_dec(x_149);
-x_169 = l_Lean_searchPathRef;
-x_170 = lean_st_ref_set(x_169, x_168, x_167);
-x_171 = lean_ctor_get(x_170, 1);
-lean_inc(x_171);
-lean_dec(x_170);
-x_172 = l_Lean_parseSearchPath(x_161, x_6);
-lean_dec(x_161);
-x_173 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_172, x_171);
-return x_173;
-}
-else
-{
-lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; 
-lean_dec(x_161);
-lean_dec(x_149);
-x_174 = lean_ctor_get(x_165, 0);
-lean_inc(x_174);
-x_175 = lean_ctor_get(x_165, 1);
+lean_object* x_175; lean_object* x_176; lean_object* x_177; 
+x_175 = lean_ctor_get(x_174, 0);
 lean_inc(x_175);
-if (lean_is_exclusive(x_165)) {
- lean_ctor_release(x_165, 0);
- lean_ctor_release(x_165, 1);
- x_176 = x_165;
-} else {
- lean_dec_ref(x_165);
- x_176 = lean_box(0);
-}
-if (lean_is_scalar(x_176)) {
- x_177 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_177 = x_176;
-}
-lean_ctor_set(x_177, 0, x_174);
-lean_ctor_set(x_177, 1, x_175);
-return x_177;
-}
-}
-else
+x_176 = lean_ctor_get(x_174, 1);
+lean_inc(x_176);
+lean_dec(x_174);
+x_177 = l_Lean_addSearchPathFromEnv(x_175, x_176);
+if (lean_obj_tag(x_177) == 0)
 {
-lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; 
-lean_dec(x_161);
-lean_dec(x_149);
-x_178 = lean_ctor_get(x_162, 0);
+lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; 
+x_178 = lean_ctor_get(x_177, 0);
 lean_inc(x_178);
-x_179 = lean_ctor_get(x_162, 1);
+x_179 = lean_ctor_get(x_177, 1);
 lean_inc(x_179);
-if (lean_is_exclusive(x_162)) {
- lean_ctor_release(x_162, 0);
- lean_ctor_release(x_162, 1);
- x_180 = x_162;
-} else {
- lean_dec_ref(x_162);
- x_180 = lean_box(0);
-}
-if (lean_is_scalar(x_180)) {
- x_181 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_181 = x_180;
-}
-lean_ctor_set(x_181, 0, x_178);
-lean_ctor_set(x_181, 1, x_179);
-return x_181;
-}
+lean_dec(x_177);
+x_180 = l_System_SearchPath_parse(x_161);
+lean_dec(x_161);
+x_181 = l_List_append___rarg(x_180, x_178);
+x_182 = l_Lean_searchPathRef;
+x_183 = lean_st_ref_set(x_182, x_181, x_179);
+x_184 = lean_ctor_get(x_183, 1);
+lean_inc(x_184);
+lean_dec(x_183);
+x_185 = l_System_SearchPath_parse(x_173);
+lean_dec(x_173);
+x_186 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_185, x_184);
+return x_186;
 }
 else
 {
-lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; 
-lean_dec(x_160);
-lean_dec(x_150);
-lean_dec(x_149);
-x_182 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_183 = lean_string_append(x_182, x_32);
-lean_dec(x_32);
-x_184 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_185 = lean_string_append(x_183, x_184);
-x_186 = lean_string_append(x_185, x_35);
-lean_dec(x_35);
-x_187 = lean_string_append(x_186, x_22);
-x_188 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_188, 0, x_187);
-x_189 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_189, 0, x_188);
-lean_ctor_set(x_189, 1, x_128);
-return x_189;
+lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; 
+lean_dec(x_173);
+lean_dec(x_161);
+x_187 = lean_ctor_get(x_177, 0);
+lean_inc(x_187);
+x_188 = lean_ctor_get(x_177, 1);
+lean_inc(x_188);
+if (lean_is_exclusive(x_177)) {
+ lean_ctor_release(x_177, 0);
+ lean_ctor_release(x_177, 1);
+ x_189 = x_177;
+} else {
+ lean_dec_ref(x_177);
+ x_189 = lean_box(0);
 }
+if (lean_is_scalar(x_189)) {
+ x_190 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_190 = x_189;
 }
-}
-else
-{
-lean_dec(x_149);
-if (lean_obj_tag(x_150) == 0)
-{
-lean_object* x_190; 
-lean_dec(x_35);
-lean_dec(x_32);
-x_190 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_190, 0, x_6);
-lean_ctor_set(x_190, 1, x_128);
+lean_ctor_set(x_190, 0, x_187);
+lean_ctor_set(x_190, 1, x_188);
 return x_190;
 }
+}
 else
 {
-lean_object* x_191; 
-x_191 = lean_ctor_get(x_150, 1);
+lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; 
+lean_dec(x_173);
+lean_dec(x_161);
+x_191 = lean_ctor_get(x_174, 0);
 lean_inc(x_191);
-if (lean_obj_tag(x_191) == 0)
-{
-lean_object* x_192; lean_object* x_193; 
-lean_dec(x_35);
-lean_dec(x_32);
-x_192 = lean_ctor_get(x_150, 0);
+x_192 = lean_ctor_get(x_174, 1);
 lean_inc(x_192);
-lean_dec(x_150);
-x_193 = l_Lean_getBuiltinSearchPath(x_128);
-if (lean_obj_tag(x_193) == 0)
+if (lean_is_exclusive(x_174)) {
+ lean_ctor_release(x_174, 0);
+ lean_ctor_release(x_174, 1);
+ x_193 = x_174;
+} else {
+ lean_dec_ref(x_174);
+ x_193 = lean_box(0);
+}
+if (lean_is_scalar(x_193)) {
+ x_194 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_194 = x_193;
+}
+lean_ctor_set(x_194, 0, x_191);
+lean_ctor_set(x_194, 1, x_192);
+return x_194;
+}
+}
+else
 {
-lean_object* x_194; lean_object* x_195; lean_object* x_196; 
-x_194 = lean_ctor_get(x_193, 0);
-lean_inc(x_194);
-x_195 = lean_ctor_get(x_193, 1);
-lean_inc(x_195);
-lean_dec(x_193);
-x_196 = l_Lean_addSearchPathFromEnv(x_194, x_195);
-if (lean_obj_tag(x_196) == 0)
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; 
+lean_dec(x_172);
+lean_dec(x_162);
+lean_dec(x_161);
+x_195 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_196 = lean_string_append(x_195, x_31);
+lean_dec(x_31);
+x_197 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_198 = lean_string_append(x_196, x_197);
+x_199 = lean_string_append(x_198, x_34);
+lean_dec(x_34);
+x_200 = lean_string_append(x_199, x_21);
+x_201 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_201, 0, x_200);
+x_202 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_202, 0, x_201);
+lean_ctor_set(x_202, 1, x_135);
+return x_202;
+}
+}
+}
+else
 {
-lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; 
-x_197 = lean_ctor_get(x_196, 0);
-lean_inc(x_197);
-x_198 = lean_ctor_get(x_196, 1);
-lean_inc(x_198);
-lean_dec(x_196);
-x_199 = l_Lean_parseSearchPath(x_22, x_197);
-x_200 = l_Lean_searchPathRef;
-x_201 = lean_st_ref_set(x_200, x_199, x_198);
-x_202 = lean_ctor_get(x_201, 1);
-lean_inc(x_202);
-lean_dec(x_201);
-x_203 = l_Lean_parseSearchPath(x_192, x_6);
-lean_dec(x_192);
-x_204 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_203, x_202);
+lean_dec(x_161);
+if (lean_obj_tag(x_162) == 0)
+{
+lean_object* x_203; lean_object* x_204; 
+lean_dec(x_34);
+lean_dec(x_31);
+x_203 = lean_box(0);
+x_204 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_204, 0, x_203);
+lean_ctor_set(x_204, 1, x_135);
 return x_204;
 }
 else
 {
-lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; 
-lean_dec(x_192);
-x_205 = lean_ctor_get(x_196, 0);
+lean_object* x_205; 
+x_205 = lean_ctor_get(x_162, 1);
 lean_inc(x_205);
-x_206 = lean_ctor_get(x_196, 1);
-lean_inc(x_206);
-if (lean_is_exclusive(x_196)) {
- lean_ctor_release(x_196, 0);
- lean_ctor_release(x_196, 1);
- x_207 = x_196;
-} else {
- lean_dec_ref(x_196);
- x_207 = lean_box(0);
-}
-if (lean_is_scalar(x_207)) {
- x_208 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_208 = x_207;
-}
-lean_ctor_set(x_208, 0, x_205);
-lean_ctor_set(x_208, 1, x_206);
-return x_208;
-}
-}
-else
+if (lean_obj_tag(x_205) == 0)
 {
-lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; 
-lean_dec(x_192);
-x_209 = lean_ctor_get(x_193, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_193, 1);
-lean_inc(x_210);
-if (lean_is_exclusive(x_193)) {
- lean_ctor_release(x_193, 0);
- lean_ctor_release(x_193, 1);
- x_211 = x_193;
-} else {
- lean_dec_ref(x_193);
- x_211 = lean_box(0);
-}
-if (lean_is_scalar(x_211)) {
- x_212 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_212 = x_211;
-}
-lean_ctor_set(x_212, 0, x_209);
-lean_ctor_set(x_212, 1, x_210);
-return x_212;
-}
-}
-else
-{
-lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; 
-lean_dec(x_191);
-lean_dec(x_150);
-x_213 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
-x_214 = lean_string_append(x_213, x_32);
-lean_dec(x_32);
-x_215 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
-x_216 = lean_string_append(x_214, x_215);
-x_217 = lean_string_append(x_216, x_35);
-lean_dec(x_35);
-x_218 = lean_string_append(x_217, x_22);
-x_219 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_219, 0, x_218);
-x_220 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_220, 0, x_219);
-lean_ctor_set(x_220, 1, x_128);
-return x_220;
-}
-}
-}
-}
-}
-}
-}
-else
-{
-uint8_t x_221; 
-lean_dec(x_35);
-lean_dec(x_32);
-x_221 = !lean_is_exclusive(x_37);
-if (x_221 == 0)
-{
-return x_37;
-}
-else
-{
-lean_object* x_222; lean_object* x_223; lean_object* x_224; 
-x_222 = lean_ctor_get(x_37, 0);
-x_223 = lean_ctor_get(x_37, 1);
-lean_inc(x_223);
-lean_inc(x_222);
-lean_dec(x_37);
-x_224 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_224, 0, x_222);
-lean_ctor_set(x_224, 1, x_223);
-return x_224;
-}
-}
-}
-else
-{
-uint8_t x_225; 
-lean_dec(x_32);
-lean_dec(x_20);
-x_225 = !lean_is_exclusive(x_34);
-if (x_225 == 0)
-{
-return x_34;
-}
-else
-{
-lean_object* x_226; lean_object* x_227; lean_object* x_228; 
-x_226 = lean_ctor_get(x_34, 0);
-x_227 = lean_ctor_get(x_34, 1);
-lean_inc(x_227);
-lean_inc(x_226);
+lean_object* x_206; lean_object* x_207; 
 lean_dec(x_34);
-x_228 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_228, 0, x_226);
-lean_ctor_set(x_228, 1, x_227);
-return x_228;
+lean_dec(x_31);
+x_206 = lean_ctor_get(x_162, 0);
+lean_inc(x_206);
+lean_dec(x_162);
+x_207 = l_Lean_getBuiltinSearchPath(x_135);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; lean_object* x_209; lean_object* x_210; 
+x_208 = lean_ctor_get(x_207, 0);
+lean_inc(x_208);
+x_209 = lean_ctor_get(x_207, 1);
+lean_inc(x_209);
+lean_dec(x_207);
+x_210 = l_Lean_addSearchPathFromEnv(x_208, x_209);
+if (lean_obj_tag(x_210) == 0)
+{
+lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; 
+x_211 = lean_ctor_get(x_210, 0);
+lean_inc(x_211);
+x_212 = lean_ctor_get(x_210, 1);
+lean_inc(x_212);
+lean_dec(x_210);
+x_213 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__7;
+x_214 = l_List_append___rarg(x_213, x_211);
+x_215 = l_Lean_searchPathRef;
+x_216 = lean_st_ref_set(x_215, x_214, x_212);
+x_217 = lean_ctor_get(x_216, 1);
+lean_inc(x_217);
+lean_dec(x_216);
+x_218 = l_System_SearchPath_parse(x_206);
+lean_dec(x_206);
+x_219 = l_List_mapM___at_Lean_Server_FileWorker_leanpkgSetupSearchPath___spec__2(x_218, x_217);
+return x_219;
+}
+else
+{
+lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; 
+lean_dec(x_206);
+x_220 = lean_ctor_get(x_210, 0);
+lean_inc(x_220);
+x_221 = lean_ctor_get(x_210, 1);
+lean_inc(x_221);
+if (lean_is_exclusive(x_210)) {
+ lean_ctor_release(x_210, 0);
+ lean_ctor_release(x_210, 1);
+ x_222 = x_210;
+} else {
+ lean_dec_ref(x_210);
+ x_222 = lean_box(0);
+}
+if (lean_is_scalar(x_222)) {
+ x_223 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_223 = x_222;
+}
+lean_ctor_set(x_223, 0, x_220);
+lean_ctor_set(x_223, 1, x_221);
+return x_223;
+}
+}
+else
+{
+lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; 
+lean_dec(x_206);
+x_224 = lean_ctor_get(x_207, 0);
+lean_inc(x_224);
+x_225 = lean_ctor_get(x_207, 1);
+lean_inc(x_225);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ x_226 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_226 = lean_box(0);
+}
+if (lean_is_scalar(x_226)) {
+ x_227 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_227 = x_226;
+}
+lean_ctor_set(x_227, 0, x_224);
+lean_ctor_set(x_227, 1, x_225);
+return x_227;
+}
+}
+else
+{
+lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; 
+lean_dec(x_205);
+lean_dec(x_162);
+x_228 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6;
+x_229 = lean_string_append(x_228, x_31);
+lean_dec(x_31);
+x_230 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5;
+x_231 = lean_string_append(x_229, x_230);
+x_232 = lean_string_append(x_231, x_34);
+lean_dec(x_34);
+x_233 = lean_string_append(x_232, x_21);
+x_234 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_234, 0, x_233);
+x_235 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_235, 0, x_234);
+lean_ctor_set(x_235, 1, x_135);
+return x_235;
+}
+}
+}
+}
 }
 }
 }
 else
 {
-uint8_t x_229; 
-lean_dec(x_26);
-lean_dec(x_20);
-x_229 = !lean_is_exclusive(x_29);
-if (x_229 == 0)
+uint8_t x_236; 
+lean_dec(x_34);
+lean_dec(x_31);
+x_236 = !lean_is_exclusive(x_36);
+if (x_236 == 0)
 {
-return x_29;
+return x_36;
 }
 else
 {
-lean_object* x_230; lean_object* x_231; lean_object* x_232; 
-x_230 = lean_ctor_get(x_29, 0);
-x_231 = lean_ctor_get(x_29, 1);
-lean_inc(x_231);
-lean_inc(x_230);
-lean_dec(x_29);
-x_232 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_232, 0, x_230);
-lean_ctor_set(x_232, 1, x_231);
-return x_232;
+lean_object* x_237; lean_object* x_238; lean_object* x_239; 
+x_237 = lean_ctor_get(x_36, 0);
+x_238 = lean_ctor_get(x_36, 1);
+lean_inc(x_238);
+lean_inc(x_237);
+lean_dec(x_36);
+x_239 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_239, 0, x_237);
+lean_ctor_set(x_239, 1, x_238);
+return x_239;
 }
 }
 }
 else
 {
-uint8_t x_233; 
-lean_dec(x_20);
-x_233 = !lean_is_exclusive(x_25);
-if (x_233 == 0)
+uint8_t x_240; 
+lean_dec(x_31);
+lean_dec(x_19);
+x_240 = !lean_is_exclusive(x_33);
+if (x_240 == 0)
 {
-return x_25;
+return x_33;
 }
 else
 {
-lean_object* x_234; lean_object* x_235; lean_object* x_236; 
-x_234 = lean_ctor_get(x_25, 0);
-x_235 = lean_ctor_get(x_25, 1);
-lean_inc(x_235);
-lean_inc(x_234);
+lean_object* x_241; lean_object* x_242; lean_object* x_243; 
+x_241 = lean_ctor_get(x_33, 0);
+x_242 = lean_ctor_get(x_33, 1);
+lean_inc(x_242);
+lean_inc(x_241);
+lean_dec(x_33);
+x_243 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_243, 0, x_241);
+lean_ctor_set(x_243, 1, x_242);
+return x_243;
+}
+}
+}
+else
+{
+uint8_t x_244; 
 lean_dec(x_25);
-x_236 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_236, 0, x_234);
-lean_ctor_set(x_236, 1, x_235);
-return x_236;
+lean_dec(x_19);
+x_244 = !lean_is_exclusive(x_28);
+if (x_244 == 0)
+{
+return x_28;
+}
+else
+{
+lean_object* x_245; lean_object* x_246; lean_object* x_247; 
+x_245 = lean_ctor_get(x_28, 0);
+x_246 = lean_ctor_get(x_28, 1);
+lean_inc(x_246);
+lean_inc(x_245);
+lean_dec(x_28);
+x_247 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_247, 0, x_245);
+lean_ctor_set(x_247, 1, x_246);
+return x_247;
 }
 }
 }
 else
 {
-uint8_t x_237; 
+uint8_t x_248; 
+lean_dec(x_19);
+x_248 = !lean_is_exclusive(x_24);
+if (x_248 == 0)
+{
+return x_24;
+}
+else
+{
+lean_object* x_249; lean_object* x_250; lean_object* x_251; 
+x_249 = lean_ctor_get(x_24, 0);
+x_250 = lean_ctor_get(x_24, 1);
+lean_inc(x_250);
+lean_inc(x_249);
+lean_dec(x_24);
+x_251 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_251, 0, x_249);
+lean_ctor_set(x_251, 1, x_250);
+return x_251;
+}
+}
+}
+else
+{
+uint8_t x_252; 
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_237 = !lean_is_exclusive(x_19);
-if (x_237 == 0)
+x_252 = !lean_is_exclusive(x_18);
+if (x_252 == 0)
 {
-return x_19;
+return x_18;
 }
 else
 {
-lean_object* x_238; lean_object* x_239; lean_object* x_240; 
-x_238 = lean_ctor_get(x_19, 0);
-x_239 = lean_ctor_get(x_19, 1);
-lean_inc(x_239);
-lean_inc(x_238);
-lean_dec(x_19);
-x_240 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_240, 0, x_238);
-lean_ctor_set(x_240, 1, x_239);
-return x_240;
+lean_object* x_253; lean_object* x_254; lean_object* x_255; 
+x_253 = lean_ctor_get(x_18, 0);
+x_254 = lean_ctor_get(x_18, 1);
+lean_inc(x_254);
+lean_inc(x_253);
+lean_dec(x_18);
+x_255 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_255, 0, x_253);
+lean_ctor_set(x_255, 1, x_254);
+return x_255;
 }
 }
 }
@@ -3810,280 +3844,466 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Server_FileWorker_compileHeader_match__3
 return x_2;
 }
 }
-lean_object* l_Lean_Server_FileWorker_compileHeader___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Server_FileWorker_compileHeader___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:
 {
-uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_5);
-if (x_7 == 0)
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_7);
+if (x_9 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
-x_8 = lean_ctor_get(x_5, 0);
-x_9 = lean_ctor_get(x_5, 1);
-lean_inc(x_1);
-lean_inc(x_9);
-lean_inc(x_8);
-x_10 = l_Lean_Elab_Command_mkState(x_8, x_9, x_1);
-x_11 = l_Lean_instInhabitedParserDescr___closed__1;
-x_12 = lean_box(0);
-x_13 = l_Array_empty___closed__1;
-lean_inc_n(x_1, 3);
-x_14 = lean_alloc_ctor(0, 7, 0);
-lean_ctor_set(x_14, 0, x_11);
-lean_ctor_set(x_14, 1, x_1);
-lean_ctor_set(x_14, 2, x_12);
-lean_ctor_set(x_14, 3, x_1);
-lean_ctor_set(x_14, 4, x_1);
-lean_ctor_set(x_14, 5, x_13);
-lean_ctor_set(x_14, 6, x_13);
-lean_inc(x_1);
-x_15 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_15, 0, x_14);
-lean_ctor_set(x_15, 1, x_1);
-x_16 = l_Lean_maxRecDepth;
-x_17 = l_Lean_Option_get___at_Lean_initFn____x40_Lean_Util_PPExt___hyg_231____spec__1(x_1, x_16);
-lean_dec(x_1);
-x_18 = !lean_is_exclusive(x_10);
-if (x_18 == 0)
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_10 = lean_ctor_get(x_7, 0);
+x_11 = lean_ctor_get(x_7, 1);
+lean_inc(x_11);
+x_12 = l_Lean_Server_publishMessages(x_1, x_11, x_2, x_8);
+if (lean_obj_tag(x_12) == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_19 = lean_ctor_get(x_10, 7);
-x_20 = lean_ctor_get(x_10, 5);
-lean_dec(x_20);
-x_21 = lean_ctor_get(x_10, 4);
-lean_dec(x_21);
-x_22 = lean_ctor_get(x_10, 3);
-lean_dec(x_22);
-x_23 = lean_ctor_get(x_10, 2);
-lean_dec(x_23);
-x_24 = lean_ctor_get(x_10, 1);
-lean_dec(x_24);
-x_25 = lean_ctor_get(x_10, 0);
+uint8_t x_13; 
+x_13 = !lean_is_exclusive(x_12);
+if (x_13 == 0)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+x_14 = lean_ctor_get(x_12, 0);
+lean_dec(x_14);
+lean_inc(x_3);
+lean_inc(x_11);
+lean_inc(x_10);
+x_15 = l_Lean_Elab_Command_mkState(x_10, x_11, x_3);
+x_16 = l_Lean_instInhabitedParserDescr___closed__1;
+x_17 = lean_box(0);
+x_18 = l_Array_empty___closed__1;
+lean_inc_n(x_3, 3);
+x_19 = lean_alloc_ctor(0, 7, 0);
+lean_ctor_set(x_19, 0, x_16);
+lean_ctor_set(x_19, 1, x_3);
+lean_ctor_set(x_19, 2, x_17);
+lean_ctor_set(x_19, 3, x_3);
+lean_ctor_set(x_19, 4, x_3);
+lean_ctor_set(x_19, 5, x_18);
+lean_ctor_set(x_19, 6, x_18);
+lean_inc(x_3);
+x_20 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_3);
+x_21 = l_Lean_maxRecDepth;
+x_22 = l_Lean_Option_get___at_Lean_initFn____x40_Lean_Util_PPExt___hyg_231____spec__1(x_3, x_21);
+lean_dec(x_3);
+x_23 = !lean_is_exclusive(x_15);
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; 
+x_24 = lean_ctor_get(x_15, 7);
+x_25 = lean_ctor_get(x_15, 5);
 lean_dec(x_25);
-x_26 = !lean_is_exclusive(x_19);
-if (x_26 == 0)
+x_26 = lean_ctor_get(x_15, 4);
+lean_dec(x_26);
+x_27 = lean_ctor_get(x_15, 3);
+lean_dec(x_27);
+x_28 = lean_ctor_get(x_15, 2);
+lean_dec(x_28);
+x_29 = lean_ctor_get(x_15, 1);
+lean_dec(x_29);
+x_30 = lean_ctor_get(x_15, 0);
+lean_dec(x_30);
+x_31 = !lean_is_exclusive(x_24);
+if (x_31 == 0)
 {
-uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_27 = 1;
-lean_ctor_set_uint8(x_19, sizeof(void*)*2, x_27);
-x_28 = l_Lean_Unhygienic_run___rarg___closed__2;
-x_29 = lean_unsigned_to_nat(1u);
-lean_ctor_set(x_10, 5, x_29);
-lean_ctor_set(x_10, 4, x_17);
-lean_ctor_set(x_10, 3, x_28);
-lean_ctor_set(x_10, 2, x_15);
-lean_ctor_set(x_10, 1, x_9);
-lean_ctor_set(x_10, 0, x_8);
-x_30 = lean_unsigned_to_nat(0u);
-x_31 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_31, 0, x_30);
-lean_ctor_set(x_31, 1, x_2);
-lean_ctor_set(x_31, 2, x_3);
-lean_ctor_set(x_31, 3, x_10);
-lean_ctor_set(x_5, 1, x_4);
-lean_ctor_set(x_5, 0, x_31);
-x_32 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_32, 0, x_5);
-lean_ctor_set(x_32, 1, x_6);
-return x_32;
+uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_32 = 1;
+lean_ctor_set_uint8(x_24, sizeof(void*)*2, x_32);
+x_33 = l_Lean_Unhygienic_run___rarg___closed__2;
+x_34 = lean_unsigned_to_nat(1u);
+lean_ctor_set(x_15, 5, x_34);
+lean_ctor_set(x_15, 4, x_22);
+lean_ctor_set(x_15, 3, x_33);
+lean_ctor_set(x_15, 2, x_20);
+lean_ctor_set(x_15, 1, x_11);
+lean_ctor_set(x_15, 0, x_10);
+x_35 = lean_unsigned_to_nat(0u);
+x_36 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_36, 0, x_35);
+lean_ctor_set(x_36, 1, x_4);
+lean_ctor_set(x_36, 2, x_5);
+lean_ctor_set(x_36, 3, x_15);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 0, x_36);
+lean_ctor_set(x_12, 0, x_7);
+return x_12;
 }
 else
 {
-lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_33 = lean_ctor_get(x_19, 0);
-x_34 = lean_ctor_get(x_19, 1);
-lean_inc(x_34);
-lean_inc(x_33);
-lean_dec(x_19);
-x_35 = 1;
-x_36 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_36, 0, x_33);
-lean_ctor_set(x_36, 1, x_34);
-lean_ctor_set_uint8(x_36, sizeof(void*)*2, x_35);
-x_37 = l_Lean_Unhygienic_run___rarg___closed__2;
-x_38 = lean_unsigned_to_nat(1u);
-lean_ctor_set(x_10, 7, x_36);
-lean_ctor_set(x_10, 5, x_38);
-lean_ctor_set(x_10, 4, x_17);
-lean_ctor_set(x_10, 3, x_37);
-lean_ctor_set(x_10, 2, x_15);
-lean_ctor_set(x_10, 1, x_9);
-lean_ctor_set(x_10, 0, x_8);
-x_39 = lean_unsigned_to_nat(0u);
-x_40 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_40, 0, x_39);
-lean_ctor_set(x_40, 1, x_2);
-lean_ctor_set(x_40, 2, x_3);
-lean_ctor_set(x_40, 3, x_10);
-lean_ctor_set(x_5, 1, x_4);
-lean_ctor_set(x_5, 0, x_40);
-x_41 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_41, 0, x_5);
-lean_ctor_set(x_41, 1, x_6);
-return x_41;
+lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_37 = lean_ctor_get(x_24, 0);
+x_38 = lean_ctor_get(x_24, 1);
+lean_inc(x_38);
+lean_inc(x_37);
+lean_dec(x_24);
+x_39 = 1;
+x_40 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_40, 0, x_37);
+lean_ctor_set(x_40, 1, x_38);
+lean_ctor_set_uint8(x_40, sizeof(void*)*2, x_39);
+x_41 = l_Lean_Unhygienic_run___rarg___closed__2;
+x_42 = lean_unsigned_to_nat(1u);
+lean_ctor_set(x_15, 7, x_40);
+lean_ctor_set(x_15, 5, x_42);
+lean_ctor_set(x_15, 4, x_22);
+lean_ctor_set(x_15, 3, x_41);
+lean_ctor_set(x_15, 2, x_20);
+lean_ctor_set(x_15, 1, x_11);
+lean_ctor_set(x_15, 0, x_10);
+x_43 = lean_unsigned_to_nat(0u);
+x_44 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_44, 0, x_43);
+lean_ctor_set(x_44, 1, x_4);
+lean_ctor_set(x_44, 2, x_5);
+lean_ctor_set(x_44, 3, x_15);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 0, x_44);
+lean_ctor_set(x_12, 0, x_7);
+return x_12;
 }
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_42 = lean_ctor_get(x_10, 7);
-x_43 = lean_ctor_get(x_10, 6);
-x_44 = lean_ctor_get(x_10, 8);
-lean_inc(x_44);
-lean_inc(x_42);
-lean_inc(x_43);
-lean_dec(x_10);
-x_45 = lean_ctor_get(x_42, 0);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_45 = lean_ctor_get(x_15, 7);
+x_46 = lean_ctor_get(x_15, 6);
+x_47 = lean_ctor_get(x_15, 8);
+lean_inc(x_47);
 lean_inc(x_45);
-x_46 = lean_ctor_get(x_42, 1);
 lean_inc(x_46);
-if (lean_is_exclusive(x_42)) {
- lean_ctor_release(x_42, 0);
- lean_ctor_release(x_42, 1);
- x_47 = x_42;
+lean_dec(x_15);
+x_48 = lean_ctor_get(x_45, 0);
+lean_inc(x_48);
+x_49 = lean_ctor_get(x_45, 1);
+lean_inc(x_49);
+if (lean_is_exclusive(x_45)) {
+ lean_ctor_release(x_45, 0);
+ lean_ctor_release(x_45, 1);
+ x_50 = x_45;
 } else {
- lean_dec_ref(x_42);
- x_47 = lean_box(0);
+ lean_dec_ref(x_45);
+ x_50 = lean_box(0);
 }
-x_48 = 1;
-if (lean_is_scalar(x_47)) {
- x_49 = lean_alloc_ctor(0, 2, 1);
+x_51 = 1;
+if (lean_is_scalar(x_50)) {
+ x_52 = lean_alloc_ctor(0, 2, 1);
 } else {
- x_49 = x_47;
+ x_52 = x_50;
 }
-lean_ctor_set(x_49, 0, x_45);
-lean_ctor_set(x_49, 1, x_46);
-lean_ctor_set_uint8(x_49, sizeof(void*)*2, x_48);
-x_50 = l_Lean_Unhygienic_run___rarg___closed__2;
-x_51 = lean_unsigned_to_nat(1u);
-x_52 = lean_alloc_ctor(0, 9, 0);
-lean_ctor_set(x_52, 0, x_8);
-lean_ctor_set(x_52, 1, x_9);
-lean_ctor_set(x_52, 2, x_15);
-lean_ctor_set(x_52, 3, x_50);
-lean_ctor_set(x_52, 4, x_17);
-lean_ctor_set(x_52, 5, x_51);
-lean_ctor_set(x_52, 6, x_43);
-lean_ctor_set(x_52, 7, x_49);
-lean_ctor_set(x_52, 8, x_44);
-x_53 = lean_unsigned_to_nat(0u);
-x_54 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_54, 0, x_53);
-lean_ctor_set(x_54, 1, x_2);
-lean_ctor_set(x_54, 2, x_3);
-lean_ctor_set(x_54, 3, x_52);
-lean_ctor_set(x_5, 1, x_4);
-lean_ctor_set(x_5, 0, x_54);
-x_55 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_55, 0, x_5);
-lean_ctor_set(x_55, 1, x_6);
-return x_55;
+lean_ctor_set(x_52, 0, x_48);
+lean_ctor_set(x_52, 1, x_49);
+lean_ctor_set_uint8(x_52, sizeof(void*)*2, x_51);
+x_53 = l_Lean_Unhygienic_run___rarg___closed__2;
+x_54 = lean_unsigned_to_nat(1u);
+x_55 = lean_alloc_ctor(0, 9, 0);
+lean_ctor_set(x_55, 0, x_10);
+lean_ctor_set(x_55, 1, x_11);
+lean_ctor_set(x_55, 2, x_20);
+lean_ctor_set(x_55, 3, x_53);
+lean_ctor_set(x_55, 4, x_22);
+lean_ctor_set(x_55, 5, x_54);
+lean_ctor_set(x_55, 6, x_46);
+lean_ctor_set(x_55, 7, x_52);
+lean_ctor_set(x_55, 8, x_47);
+x_56 = lean_unsigned_to_nat(0u);
+x_57 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_57, 0, x_56);
+lean_ctor_set(x_57, 1, x_4);
+lean_ctor_set(x_57, 2, x_5);
+lean_ctor_set(x_57, 3, x_55);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 0, x_57);
+lean_ctor_set(x_12, 0, x_7);
+return x_12;
 }
 }
 else
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-x_56 = lean_ctor_get(x_5, 0);
-x_57 = lean_ctor_get(x_5, 1);
-lean_inc(x_57);
-lean_inc(x_56);
-lean_dec(x_5);
-lean_inc(x_1);
-lean_inc(x_57);
-lean_inc(x_56);
-x_58 = l_Lean_Elab_Command_mkState(x_56, x_57, x_1);
-x_59 = l_Lean_instInhabitedParserDescr___closed__1;
-x_60 = lean_box(0);
-x_61 = l_Array_empty___closed__1;
-lean_inc_n(x_1, 3);
-x_62 = lean_alloc_ctor(0, 7, 0);
-lean_ctor_set(x_62, 0, x_59);
-lean_ctor_set(x_62, 1, x_1);
-lean_ctor_set(x_62, 2, x_60);
-lean_ctor_set(x_62, 3, x_1);
-lean_ctor_set(x_62, 4, x_1);
-lean_ctor_set(x_62, 5, x_61);
-lean_ctor_set(x_62, 6, x_61);
-lean_inc(x_1);
-x_63 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_63, 0, x_62);
-lean_ctor_set(x_63, 1, x_1);
-x_64 = l_Lean_maxRecDepth;
-x_65 = l_Lean_Option_get___at_Lean_initFn____x40_Lean_Util_PPExt___hyg_231____spec__1(x_1, x_64);
-lean_dec(x_1);
-x_66 = lean_ctor_get(x_58, 7);
-lean_inc(x_66);
-x_67 = lean_ctor_get(x_58, 6);
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
+x_58 = lean_ctor_get(x_12, 1);
+lean_inc(x_58);
+lean_dec(x_12);
+lean_inc(x_3);
+lean_inc(x_11);
+lean_inc(x_10);
+x_59 = l_Lean_Elab_Command_mkState(x_10, x_11, x_3);
+x_60 = l_Lean_instInhabitedParserDescr___closed__1;
+x_61 = lean_box(0);
+x_62 = l_Array_empty___closed__1;
+lean_inc_n(x_3, 3);
+x_63 = lean_alloc_ctor(0, 7, 0);
+lean_ctor_set(x_63, 0, x_60);
+lean_ctor_set(x_63, 1, x_3);
+lean_ctor_set(x_63, 2, x_61);
+lean_ctor_set(x_63, 3, x_3);
+lean_ctor_set(x_63, 4, x_3);
+lean_ctor_set(x_63, 5, x_62);
+lean_ctor_set(x_63, 6, x_62);
+lean_inc(x_3);
+x_64 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_64, 0, x_63);
+lean_ctor_set(x_64, 1, x_3);
+x_65 = l_Lean_maxRecDepth;
+x_66 = l_Lean_Option_get___at_Lean_initFn____x40_Lean_Util_PPExt___hyg_231____spec__1(x_3, x_65);
+lean_dec(x_3);
+x_67 = lean_ctor_get(x_59, 7);
 lean_inc(x_67);
-x_68 = lean_ctor_get(x_58, 8);
+x_68 = lean_ctor_get(x_59, 6);
 lean_inc(x_68);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- lean_ctor_release(x_58, 2);
- lean_ctor_release(x_58, 3);
- lean_ctor_release(x_58, 4);
- lean_ctor_release(x_58, 5);
- lean_ctor_release(x_58, 6);
- lean_ctor_release(x_58, 7);
- lean_ctor_release(x_58, 8);
- x_69 = x_58;
+x_69 = lean_ctor_get(x_59, 8);
+lean_inc(x_69);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ lean_ctor_release(x_59, 2);
+ lean_ctor_release(x_59, 3);
+ lean_ctor_release(x_59, 4);
+ lean_ctor_release(x_59, 5);
+ lean_ctor_release(x_59, 6);
+ lean_ctor_release(x_59, 7);
+ lean_ctor_release(x_59, 8);
+ x_70 = x_59;
 } else {
- lean_dec_ref(x_58);
- x_69 = lean_box(0);
+ lean_dec_ref(x_59);
+ x_70 = lean_box(0);
 }
-x_70 = lean_ctor_get(x_66, 0);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_66, 1);
+x_71 = lean_ctor_get(x_67, 0);
 lean_inc(x_71);
-if (lean_is_exclusive(x_66)) {
- lean_ctor_release(x_66, 0);
- lean_ctor_release(x_66, 1);
- x_72 = x_66;
+x_72 = lean_ctor_get(x_67, 1);
+lean_inc(x_72);
+if (lean_is_exclusive(x_67)) {
+ lean_ctor_release(x_67, 0);
+ lean_ctor_release(x_67, 1);
+ x_73 = x_67;
 } else {
- lean_dec_ref(x_66);
- x_72 = lean_box(0);
+ lean_dec_ref(x_67);
+ x_73 = lean_box(0);
 }
-x_73 = 1;
-if (lean_is_scalar(x_72)) {
- x_74 = lean_alloc_ctor(0, 2, 1);
+x_74 = 1;
+if (lean_is_scalar(x_73)) {
+ x_75 = lean_alloc_ctor(0, 2, 1);
 } else {
- x_74 = x_72;
+ x_75 = x_73;
 }
-lean_ctor_set(x_74, 0, x_70);
-lean_ctor_set(x_74, 1, x_71);
-lean_ctor_set_uint8(x_74, sizeof(void*)*2, x_73);
-x_75 = l_Lean_Unhygienic_run___rarg___closed__2;
-x_76 = lean_unsigned_to_nat(1u);
-if (lean_is_scalar(x_69)) {
- x_77 = lean_alloc_ctor(0, 9, 0);
+lean_ctor_set(x_75, 0, x_71);
+lean_ctor_set(x_75, 1, x_72);
+lean_ctor_set_uint8(x_75, sizeof(void*)*2, x_74);
+x_76 = l_Lean_Unhygienic_run___rarg___closed__2;
+x_77 = lean_unsigned_to_nat(1u);
+if (lean_is_scalar(x_70)) {
+ x_78 = lean_alloc_ctor(0, 9, 0);
 } else {
- x_77 = x_69;
+ x_78 = x_70;
 }
-lean_ctor_set(x_77, 0, x_56);
-lean_ctor_set(x_77, 1, x_57);
-lean_ctor_set(x_77, 2, x_63);
-lean_ctor_set(x_77, 3, x_75);
-lean_ctor_set(x_77, 4, x_65);
-lean_ctor_set(x_77, 5, x_76);
-lean_ctor_set(x_77, 6, x_67);
-lean_ctor_set(x_77, 7, x_74);
-lean_ctor_set(x_77, 8, x_68);
-x_78 = lean_unsigned_to_nat(0u);
-x_79 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_79, 0, x_78);
-lean_ctor_set(x_79, 1, x_2);
-lean_ctor_set(x_79, 2, x_3);
-lean_ctor_set(x_79, 3, x_77);
-x_80 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_78, 0, x_10);
+lean_ctor_set(x_78, 1, x_11);
+lean_ctor_set(x_78, 2, x_64);
+lean_ctor_set(x_78, 3, x_76);
+lean_ctor_set(x_78, 4, x_66);
+lean_ctor_set(x_78, 5, x_77);
+lean_ctor_set(x_78, 6, x_68);
+lean_ctor_set(x_78, 7, x_75);
+lean_ctor_set(x_78, 8, x_69);
+x_79 = lean_unsigned_to_nat(0u);
+x_80 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_80, 0, x_79);
 lean_ctor_set(x_80, 1, x_4);
+lean_ctor_set(x_80, 2, x_5);
+lean_ctor_set(x_80, 3, x_78);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 0, x_80);
 x_81 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_81, 0, x_80);
-lean_ctor_set(x_81, 1, x_6);
+lean_ctor_set(x_81, 0, x_7);
+lean_ctor_set(x_81, 1, x_58);
 return x_81;
 }
 }
+else
+{
+uint8_t x_82; 
+lean_free_object(x_7);
+lean_dec(x_11);
+lean_dec(x_10);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_82 = !lean_is_exclusive(x_12);
+if (x_82 == 0)
+{
+return x_12;
+}
+else
+{
+lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+x_83 = lean_ctor_get(x_12, 0);
+x_84 = lean_ctor_get(x_12, 1);
+lean_inc(x_84);
+lean_inc(x_83);
+lean_dec(x_12);
+x_85 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_85, 0, x_83);
+lean_ctor_set(x_85, 1, x_84);
+return x_85;
+}
+}
+}
+else
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; 
+x_86 = lean_ctor_get(x_7, 0);
+x_87 = lean_ctor_get(x_7, 1);
+lean_inc(x_87);
+lean_inc(x_86);
+lean_dec(x_7);
+lean_inc(x_87);
+x_88 = l_Lean_Server_publishMessages(x_1, x_87, x_2, x_8);
+if (lean_obj_tag(x_88) == 0)
+{
+lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; uint8_t 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; 
+x_89 = lean_ctor_get(x_88, 1);
+lean_inc(x_89);
+if (lean_is_exclusive(x_88)) {
+ lean_ctor_release(x_88, 0);
+ lean_ctor_release(x_88, 1);
+ x_90 = x_88;
+} else {
+ lean_dec_ref(x_88);
+ x_90 = lean_box(0);
+}
+lean_inc(x_3);
+lean_inc(x_87);
+lean_inc(x_86);
+x_91 = l_Lean_Elab_Command_mkState(x_86, x_87, x_3);
+x_92 = l_Lean_instInhabitedParserDescr___closed__1;
+x_93 = lean_box(0);
+x_94 = l_Array_empty___closed__1;
+lean_inc_n(x_3, 3);
+x_95 = lean_alloc_ctor(0, 7, 0);
+lean_ctor_set(x_95, 0, x_92);
+lean_ctor_set(x_95, 1, x_3);
+lean_ctor_set(x_95, 2, x_93);
+lean_ctor_set(x_95, 3, x_3);
+lean_ctor_set(x_95, 4, x_3);
+lean_ctor_set(x_95, 5, x_94);
+lean_ctor_set(x_95, 6, x_94);
+lean_inc(x_3);
+x_96 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_96, 0, x_95);
+lean_ctor_set(x_96, 1, x_3);
+x_97 = l_Lean_maxRecDepth;
+x_98 = l_Lean_Option_get___at_Lean_initFn____x40_Lean_Util_PPExt___hyg_231____spec__1(x_3, x_97);
+lean_dec(x_3);
+x_99 = lean_ctor_get(x_91, 7);
+lean_inc(x_99);
+x_100 = lean_ctor_get(x_91, 6);
+lean_inc(x_100);
+x_101 = lean_ctor_get(x_91, 8);
+lean_inc(x_101);
+if (lean_is_exclusive(x_91)) {
+ lean_ctor_release(x_91, 0);
+ lean_ctor_release(x_91, 1);
+ lean_ctor_release(x_91, 2);
+ lean_ctor_release(x_91, 3);
+ lean_ctor_release(x_91, 4);
+ lean_ctor_release(x_91, 5);
+ lean_ctor_release(x_91, 6);
+ lean_ctor_release(x_91, 7);
+ lean_ctor_release(x_91, 8);
+ x_102 = x_91;
+} else {
+ lean_dec_ref(x_91);
+ x_102 = lean_box(0);
+}
+x_103 = lean_ctor_get(x_99, 0);
+lean_inc(x_103);
+x_104 = lean_ctor_get(x_99, 1);
+lean_inc(x_104);
+if (lean_is_exclusive(x_99)) {
+ lean_ctor_release(x_99, 0);
+ lean_ctor_release(x_99, 1);
+ x_105 = x_99;
+} else {
+ lean_dec_ref(x_99);
+ x_105 = lean_box(0);
+}
+x_106 = 1;
+if (lean_is_scalar(x_105)) {
+ x_107 = lean_alloc_ctor(0, 2, 1);
+} else {
+ x_107 = x_105;
+}
+lean_ctor_set(x_107, 0, x_103);
+lean_ctor_set(x_107, 1, x_104);
+lean_ctor_set_uint8(x_107, sizeof(void*)*2, x_106);
+x_108 = l_Lean_Unhygienic_run___rarg___closed__2;
+x_109 = lean_unsigned_to_nat(1u);
+if (lean_is_scalar(x_102)) {
+ x_110 = lean_alloc_ctor(0, 9, 0);
+} else {
+ x_110 = x_102;
+}
+lean_ctor_set(x_110, 0, x_86);
+lean_ctor_set(x_110, 1, x_87);
+lean_ctor_set(x_110, 2, x_96);
+lean_ctor_set(x_110, 3, x_108);
+lean_ctor_set(x_110, 4, x_98);
+lean_ctor_set(x_110, 5, x_109);
+lean_ctor_set(x_110, 6, x_100);
+lean_ctor_set(x_110, 7, x_107);
+lean_ctor_set(x_110, 8, x_101);
+x_111 = lean_unsigned_to_nat(0u);
+x_112 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_112, 0, x_111);
+lean_ctor_set(x_112, 1, x_4);
+lean_ctor_set(x_112, 2, x_5);
+lean_ctor_set(x_112, 3, x_110);
+x_113 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_113, 0, x_112);
+lean_ctor_set(x_113, 1, x_6);
+if (lean_is_scalar(x_90)) {
+ x_114 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_114 = x_90;
+}
+lean_ctor_set(x_114, 0, x_113);
+lean_ctor_set(x_114, 1, x_89);
+return x_114;
+}
+else
+{
+lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
+lean_dec(x_87);
+lean_dec(x_86);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_115 = lean_ctor_get(x_88, 0);
+lean_inc(x_115);
+x_116 = lean_ctor_get(x_88, 1);
+lean_inc(x_116);
+if (lean_is_exclusive(x_88)) {
+ lean_ctor_release(x_88, 0);
+ lean_ctor_release(x_88, 1);
+ x_117 = x_88;
+} else {
+ lean_dec_ref(x_88);
+ x_117 = lean_box(0);
+}
+if (lean_is_scalar(x_117)) {
+ x_118 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_118 = x_117;
+}
+lean_ctor_set(x_118, 0, x_115);
+lean_ctor_set(x_118, 1, x_116);
+return x_118;
+}
+}
+}
 }
 lean_object* l_Lean_Server_FileWorker_compileHeader___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
@@ -4150,149 +4370,127 @@ return x_20;
 lean_object* l_Lean_Server_FileWorker_compileHeader___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) {
 _start:
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_42; 
-x_42 = lean_io_file_exists(x_6, x_11);
-if (lean_obj_tag(x_42) == 0)
+lean_object* x_12; lean_object* x_13; lean_object* x_36; lean_object* x_37; uint8_t x_38; 
+x_36 = l_System_FilePath_pathExists(x_6, x_11);
+x_37 = lean_ctor_get(x_36, 0);
+lean_inc(x_37);
+x_38 = lean_unbox(x_37);
+lean_dec(x_37);
+if (x_38 == 0)
 {
-lean_object* x_43; uint8_t x_44; 
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-x_44 = lean_unbox(x_43);
-lean_dec(x_43);
-if (x_44 == 0)
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
 lean_dec(x_6);
-x_45 = lean_ctor_get(x_42, 1);
+x_39 = lean_ctor_get(x_36, 1);
+lean_inc(x_39);
+lean_dec(x_36);
+x_40 = lean_box(0);
+lean_inc(x_9);
+lean_inc(x_3);
+x_41 = l_Lean_Server_FileWorker_compileHeader___lambda__2(x_4, x_3, x_7, x_8, x_9, x_40, x_39);
+if (lean_obj_tag(x_41) == 0)
+{
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_9);
+x_42 = lean_ctor_get(x_41, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_41, 1);
+lean_inc(x_43);
+lean_dec(x_41);
+x_44 = lean_ctor_get(x_42, 1);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_42, 0);
 lean_inc(x_45);
 lean_dec(x_42);
-x_46 = lean_box(0);
-lean_inc(x_9);
-lean_inc(x_1);
-x_47 = l_Lean_Server_FileWorker_compileHeader___lambda__2(x_2, x_1, x_7, x_8, x_9, x_46, x_45);
-if (lean_obj_tag(x_47) == 0)
+x_46 = l_Lean_Server_FileWorker_compileHeader___lambda__1(x_1, x_2, x_3, x_4, x_5, x_44, x_45, x_43);
+return x_46;
+}
+else
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_4);
-x_48 = lean_ctor_get(x_47, 0);
+lean_object* x_47; lean_object* x_48; 
+x_47 = lean_ctor_get(x_41, 0);
+lean_inc(x_47);
+x_48 = lean_ctor_get(x_41, 1);
 lean_inc(x_48);
-x_49 = lean_ctor_get(x_47, 1);
+lean_dec(x_41);
+x_12 = x_47;
+x_13 = x_48;
+goto block_35;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_49 = lean_ctor_get(x_36, 1);
 lean_inc(x_49);
-lean_dec(x_47);
-x_50 = lean_ctor_get(x_48, 1);
-lean_inc(x_50);
-x_51 = lean_ctor_get(x_48, 0);
-lean_inc(x_51);
-lean_dec(x_48);
-x_52 = l_Lean_Server_FileWorker_compileHeader___lambda__1(x_1, x_2, x_3, x_50, x_51, x_49);
-return x_52;
-}
-else
+lean_dec(x_36);
+x_50 = l_Lean_Elab_headerToImports(x_4);
+x_51 = l_List_redLength___rarg(x_50);
+x_52 = lean_mk_empty_array_with_capacity(x_51);
+lean_dec(x_51);
+x_53 = l_List_toArrayAux___rarg(x_50, x_52);
+lean_inc(x_2);
+lean_inc(x_1);
+x_54 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath(x_6, x_1, x_53, x_2, x_49);
+if (lean_obj_tag(x_54) == 0)
 {
-lean_object* x_53; lean_object* x_54; 
-x_53 = lean_ctor_get(x_47, 0);
-lean_inc(x_53);
-x_54 = lean_ctor_get(x_47, 1);
-lean_inc(x_54);
-lean_dec(x_47);
-x_12 = x_53;
-x_13 = x_54;
-goto block_41;
-}
-}
-else
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_55 = lean_ctor_get(x_42, 1);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_55 = lean_ctor_get(x_54, 0);
 lean_inc(x_55);
-lean_dec(x_42);
-x_56 = l_Lean_Elab_headerToImports(x_2);
-x_57 = l_List_redLength___rarg(x_56);
-x_58 = lean_mk_empty_array_with_capacity(x_57);
-lean_dec(x_57);
-x_59 = l_List_toArrayAux___rarg(x_56, x_58);
-lean_inc(x_5);
-lean_inc(x_4);
-x_60 = l_Lean_Server_FileWorker_leanpkgSetupSearchPath(x_6, x_4, x_59, x_5, x_55);
-if (lean_obj_tag(x_60) == 0)
+x_56 = lean_ctor_get(x_54, 1);
+lean_inc(x_56);
+lean_dec(x_54);
+lean_inc(x_9);
+x_57 = l_List_append___rarg(x_9, x_55);
+x_58 = lean_box(0);
+lean_inc(x_3);
+x_59 = l_Lean_Server_FileWorker_compileHeader___lambda__2(x_4, x_3, x_7, x_8, x_57, x_58, x_56);
+if (lean_obj_tag(x_59) == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-x_61 = lean_ctor_get(x_60, 0);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+lean_dec(x_9);
+x_60 = lean_ctor_get(x_59, 0);
+lean_inc(x_60);
+x_61 = lean_ctor_get(x_59, 1);
 lean_inc(x_61);
+lean_dec(x_59);
 x_62 = lean_ctor_get(x_60, 1);
 lean_inc(x_62);
+x_63 = lean_ctor_get(x_60, 0);
+lean_inc(x_63);
 lean_dec(x_60);
-lean_inc(x_9);
-x_63 = l_List_append___rarg(x_9, x_61);
-x_64 = lean_box(0);
-lean_inc(x_1);
-x_65 = l_Lean_Server_FileWorker_compileHeader___lambda__2(x_2, x_1, x_7, x_8, x_63, x_64, x_62);
-if (lean_obj_tag(x_65) == 0)
+x_64 = l_Lean_Server_FileWorker_compileHeader___lambda__1(x_1, x_2, x_3, x_4, x_5, x_62, x_63, x_61);
+return x_64;
+}
+else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_4);
-x_66 = lean_ctor_get(x_65, 0);
+lean_object* x_65; lean_object* x_66; 
+x_65 = lean_ctor_get(x_59, 0);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_59, 1);
 lean_inc(x_66);
-x_67 = lean_ctor_get(x_65, 1);
+lean_dec(x_59);
+x_12 = x_65;
+x_13 = x_66;
+goto block_35;
+}
+}
+else
+{
+lean_object* x_67; lean_object* x_68; 
+lean_dec(x_7);
+x_67 = lean_ctor_get(x_54, 0);
 lean_inc(x_67);
-lean_dec(x_65);
-x_68 = lean_ctor_get(x_66, 1);
+x_68 = lean_ctor_get(x_54, 1);
 lean_inc(x_68);
-x_69 = lean_ctor_get(x_66, 0);
-lean_inc(x_69);
-lean_dec(x_66);
-x_70 = l_Lean_Server_FileWorker_compileHeader___lambda__1(x_1, x_2, x_3, x_68, x_69, x_67);
-return x_70;
+lean_dec(x_54);
+x_12 = x_67;
+x_13 = x_68;
+goto block_35;
 }
-else
+}
+block_35:
 {
-lean_object* x_71; lean_object* x_72; 
-x_71 = lean_ctor_get(x_65, 0);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_65, 1);
-lean_inc(x_72);
-lean_dec(x_65);
-x_12 = x_71;
-x_13 = x_72;
-goto block_41;
-}
-}
-else
-{
-lean_object* x_73; lean_object* x_74; 
-lean_dec(x_7);
-x_73 = lean_ctor_get(x_60, 0);
-lean_inc(x_73);
-x_74 = lean_ctor_get(x_60, 1);
-lean_inc(x_74);
-lean_dec(x_60);
-x_12 = x_73;
-x_13 = x_74;
-goto block_41;
-}
-}
-}
-else
-{
-lean_object* x_75; lean_object* x_76; 
-lean_dec(x_7);
-lean_dec(x_6);
-x_75 = lean_ctor_get(x_42, 0);
-lean_inc(x_75);
-x_76 = lean_ctor_get(x_42, 1);
-lean_inc(x_76);
-lean_dec(x_42);
-x_12 = x_75;
-x_13 = x_76;
-goto block_41;
-}
-block_41:
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint32_t x_25; lean_object* x_26; 
 x_14 = lean_box(0);
 x_15 = lean_io_error_to_string(x_12);
 x_16 = lean_alloc_ctor(2, 1, 0);
@@ -4312,83 +4510,49 @@ lean_ctor_set(x_22, 4, x_17);
 lean_ctor_set_uint8(x_22, sizeof(void*)*5, x_20);
 x_23 = l_Lean_MessageLog_empty;
 x_24 = l_Std_PersistentArray_push___rarg(x_23, x_22);
-lean_inc(x_24);
-x_25 = l_Lean_Server_publishMessages(x_4, x_24, x_5, x_13);
-if (lean_obj_tag(x_25) == 0)
+x_25 = 0;
+x_26 = lean_mk_empty_environment(x_25, x_13);
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_26; uint32_t x_27; lean_object* x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = 0;
-x_28 = lean_mk_empty_environment(x_27, x_26);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = lean_ctor_get(x_28, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_28, 1);
-lean_inc(x_30);
-lean_dec(x_28);
-x_31 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_31, 0, x_29);
-lean_ctor_set(x_31, 1, x_24);
-x_32 = l_Lean_Server_FileWorker_compileHeader___lambda__1(x_1, x_2, x_3, x_9, x_31, x_30);
-return x_32;
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_27 = lean_ctor_get(x_26, 0);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_26, 1);
+lean_inc(x_28);
+lean_dec(x_26);
+x_29 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_29, 0, x_27);
+lean_ctor_set(x_29, 1, x_24);
+x_30 = l_Lean_Server_FileWorker_compileHeader___lambda__1(x_1, x_2, x_3, x_4, x_5, x_9, x_29, x_28);
+return x_30;
 }
 else
 {
-uint8_t x_33; 
+uint8_t x_31; 
 lean_dec(x_24);
 lean_dec(x_9);
+lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_33 = !lean_is_exclusive(x_28);
-if (x_33 == 0)
+x_31 = !lean_is_exclusive(x_26);
+if (x_31 == 0)
 {
-return x_28;
+return x_26;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_34 = lean_ctor_get(x_28, 0);
-x_35 = lean_ctor_get(x_28, 1);
-lean_inc(x_35);
-lean_inc(x_34);
-lean_dec(x_28);
-x_36 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_36, 0, x_34);
-lean_ctor_set(x_36, 1, x_35);
-return x_36;
-}
-}
-}
-else
-{
-uint8_t x_37; 
-lean_dec(x_24);
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-x_37 = !lean_is_exclusive(x_25);
-if (x_37 == 0)
-{
-return x_25;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-x_38 = lean_ctor_get(x_25, 0);
-x_39 = lean_ctor_get(x_25, 1);
-lean_inc(x_39);
-lean_inc(x_38);
-lean_dec(x_25);
-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_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_32 = lean_ctor_get(x_26, 0);
+x_33 = lean_ctor_get(x_26, 1);
+lean_inc(x_33);
+lean_inc(x_32);
+lean_dec(x_26);
+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;
 }
 }
 }
@@ -4398,7 +4562,7 @@ static lean_object* _init_l_Lean_Server_FileWorker_compileHeader___lambda__4___c
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("/../lib/lean/src");
+x_1 = lean_mk_string("src");
 return x_1;
 }
 }
@@ -4413,118 +4577,122 @@ return x_1;
 lean_object* l_Lean_Server_FileWorker_compileHeader___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
 _start:
 {
-lean_object* x_10; 
-x_10 = l_IO_appDir___at_Lean_getBuiltinSearchPath___spec__1(x_9);
-if (lean_obj_tag(x_10) == 0)
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_10 = l_System_FilePath_exeExtension;
+x_11 = l_System_FilePath_withExtension(x_8, x_10);
+x_12 = l_IO_appDir___at_Lean_getBuiltinSearchPath___spec__1(x_9);
+if (lean_obj_tag(x_12) == 0)
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-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 = l_Lean_instInhabitedParserDescr___closed__1;
-x_14 = lean_string_append(x_13, x_11);
-lean_dec(x_11);
-x_15 = l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__1;
-x_16 = lean_string_append(x_14, x_15);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_13 = lean_ctor_get(x_12, 0);
+lean_inc(x_13);
+x_14 = lean_ctor_get(x_12, 1);
+lean_inc(x_14);
+lean_dec(x_12);
+x_15 = l_Lean_Syntax_formatStxAux___closed__3;
+x_16 = l_System_FilePath_join(x_13, x_15);
+x_17 = l_Lean_getBuiltinSearchPath___lambda__1___closed__1;
+x_18 = l_System_FilePath_join(x_16, x_17);
+x_19 = l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
+x_20 = l_System_FilePath_join(x_18, x_19);
+x_21 = l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__1;
+x_22 = l_System_FilePath_join(x_20, x_21);
 lean_inc(x_1);
-x_17 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_17, 0, x_16);
-lean_ctor_set(x_17, 1, x_1);
-x_18 = l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__2;
-x_19 = lean_io_getenv(x_18, x_12);
-if (lean_obj_tag(x_19) == 0)
+x_23 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_23, 0, x_22);
+lean_ctor_set(x_23, 1, x_1);
+x_24 = l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__2;
+x_25 = lean_io_getenv(x_24, x_14);
+if (lean_obj_tag(x_25) == 0)
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 0);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+lean_object* x_26; 
+x_26 = lean_ctor_get(x_25, 0);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-lean_dec(x_19);
-x_22 = lean_box(0);
-x_23 = l_Lean_Server_FileWorker_compileHeader___lambda__3(x_1, x_2, x_3, x_4, x_5, x_8, x_6, x_7, x_17, x_22, x_21);
-return x_23;
-}
-else
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_24 = lean_ctor_get(x_19, 1);
-lean_inc(x_24);
-lean_dec(x_19);
-x_25 = lean_ctor_get(x_20, 0);
-lean_inc(x_25);
-lean_dec(x_20);
-lean_inc(x_1);
-x_26 = l_Lean_parseSearchPath(x_25, x_1);
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_ctor_get(x_25, 1);
+lean_inc(x_27);
 lean_dec(x_25);
-x_27 = l_List_append___rarg(x_17, x_26);
 x_28 = lean_box(0);
-x_29 = l_Lean_Server_FileWorker_compileHeader___lambda__3(x_1, x_2, x_3, x_4, x_5, x_8, x_6, x_7, x_27, x_28, x_24);
+x_29 = l_Lean_Server_FileWorker_compileHeader___lambda__3(x_2, x_3, x_1, x_4, x_5, x_11, x_6, x_7, x_23, x_28, x_27);
 return x_29;
 }
-}
 else
 {
-uint8_t x_30; 
-lean_dec(x_17);
-lean_dec(x_8);
-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_30 = !lean_is_exclusive(x_19);
-if (x_30 == 0)
-{
-return x_19;
-}
-else
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_31 = lean_ctor_get(x_19, 0);
-x_32 = lean_ctor_get(x_19, 1);
-lean_inc(x_32);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_30 = lean_ctor_get(x_25, 1);
+lean_inc(x_30);
+lean_dec(x_25);
+x_31 = lean_ctor_get(x_26, 0);
 lean_inc(x_31);
-lean_dec(x_19);
-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;
-}
+lean_dec(x_26);
+x_32 = l_System_SearchPath_parse(x_31);
+lean_dec(x_31);
+x_33 = l_List_append___rarg(x_23, x_32);
+x_34 = lean_box(0);
+x_35 = l_Lean_Server_FileWorker_compileHeader___lambda__3(x_2, x_3, x_1, x_4, x_5, x_11, x_6, x_7, x_33, x_34, x_30);
+return x_35;
 }
 }
 else
 {
-uint8_t x_34; 
-lean_dec(x_8);
+uint8_t x_36; 
+lean_dec(x_23);
+lean_dec(x_11);
 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_34 = !lean_is_exclusive(x_10);
-if (x_34 == 0)
+x_36 = !lean_is_exclusive(x_25);
+if (x_36 == 0)
 {
-return x_10;
+return x_25;
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_10, 0);
-x_36 = lean_ctor_get(x_10, 1);
-lean_inc(x_36);
-lean_inc(x_35);
-lean_dec(x_10);
-x_37 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_36);
-return x_37;
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_37 = lean_ctor_get(x_25, 0);
+x_38 = lean_ctor_get(x_25, 1);
+lean_inc(x_38);
+lean_inc(x_37);
+lean_dec(x_25);
+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_40; 
+lean_dec(x_11);
+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_40 = !lean_is_exclusive(x_12);
+if (x_40 == 0)
+{
+return x_12;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_41 = lean_ctor_get(x_12, 0);
+x_42 = lean_ctor_get(x_12, 1);
+lean_inc(x_42);
+lean_inc(x_41);
+lean_dec(x_12);
+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;
 }
 }
 }
@@ -4541,7 +4709,7 @@ static lean_object* _init_l_Lean_Server_FileWorker_compileHeader___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("/leanpkg");
+x_1 = lean_mk_string("leanpkg");
 return x_1;
 }
 }
@@ -4549,7 +4717,7 @@ static lean_object* _init_l_Lean_Server_FileWorker_compileHeader___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("/bin/leanpkg");
+x_1 = lean_mk_string("bin");
 return x_1;
 }
 }
@@ -4601,127 +4769,117 @@ lean_dec(x_17);
 x_20 = l_IO_appDir___at_Lean_getBuiltinSearchPath___spec__1(x_19);
 if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
 x_21 = lean_ctor_get(x_20, 0);
 lean_inc(x_21);
 x_22 = lean_ctor_get(x_20, 1);
 lean_inc(x_22);
 lean_dec(x_20);
-x_23 = l_Lean_instInhabitedParserDescr___closed__1;
-x_24 = lean_string_append(x_23, x_21);
-lean_dec(x_21);
-x_25 = l_Lean_Server_FileWorker_compileHeader___closed__2;
-x_26 = lean_string_append(x_24, x_25);
-x_27 = l_System_FilePath_exeSuffix;
-x_28 = lean_string_append(x_26, x_27);
-x_29 = lean_string_append(x_28, x_23);
-x_30 = l_Lean_Server_FileWorker_compileHeader___lambda__4(x_4, x_13, x_14, x_1, x_2, x_15, x_8, x_29, x_22);
+x_23 = l_Lean_Server_FileWorker_compileHeader___closed__2;
+x_24 = l_System_FilePath_join(x_21, x_23);
+x_25 = l_Lean_Server_FileWorker_compileHeader___lambda__4(x_4, x_1, x_2, x_13, x_14, x_15, x_8, x_24, x_22);
 lean_dec(x_8);
-return x_30;
+return x_25;
 }
 else
 {
-uint8_t x_31; 
+uint8_t x_26; 
 lean_dec(x_15);
 lean_dec(x_14);
 lean_dec(x_13);
 lean_dec(x_8);
 lean_dec(x_2);
 lean_dec(x_1);
-x_31 = !lean_is_exclusive(x_20);
-if (x_31 == 0)
+x_26 = !lean_is_exclusive(x_20);
+if (x_26 == 0)
 {
 return x_20;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_32 = lean_ctor_get(x_20, 0);
-x_33 = lean_ctor_get(x_20, 1);
-lean_inc(x_33);
-lean_inc(x_32);
+lean_object* x_27; lean_object* x_28; lean_object* 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_dec(x_20);
-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;
+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
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_35 = lean_ctor_get(x_17, 1);
-lean_inc(x_35);
+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_30 = lean_ctor_get(x_17, 1);
+lean_inc(x_30);
 lean_dec(x_17);
-x_36 = lean_ctor_get(x_18, 0);
-lean_inc(x_36);
+x_31 = lean_ctor_get(x_18, 0);
+lean_inc(x_31);
 lean_dec(x_18);
-x_37 = l_Lean_instInhabitedParserDescr___closed__1;
-x_38 = lean_string_append(x_37, x_36);
-lean_dec(x_36);
-x_39 = l_Lean_Server_FileWorker_compileHeader___closed__3;
-x_40 = lean_string_append(x_38, x_39);
-x_41 = l_System_FilePath_exeSuffix;
-x_42 = lean_string_append(x_40, x_41);
-x_43 = lean_string_append(x_42, x_37);
-x_44 = l_Lean_Server_FileWorker_compileHeader___lambda__4(x_4, x_13, x_14, x_1, x_2, x_15, x_8, x_43, x_35);
+x_32 = l_Lean_Server_FileWorker_compileHeader___closed__3;
+x_33 = l_System_FilePath_join(x_31, x_32);
+x_34 = l_Lean_Server_FileWorker_compileHeader___closed__2;
+x_35 = l_System_FilePath_join(x_33, x_34);
+x_36 = l_Lean_Server_FileWorker_compileHeader___lambda__4(x_4, x_1, x_2, x_13, x_14, x_15, x_8, x_35, x_30);
 lean_dec(x_8);
-return x_44;
+return x_36;
 }
 }
 else
 {
-uint8_t x_45; 
+uint8_t x_37; 
 lean_dec(x_15);
 lean_dec(x_14);
 lean_dec(x_13);
 lean_dec(x_8);
 lean_dec(x_2);
 lean_dec(x_1);
-x_45 = !lean_is_exclusive(x_17);
-if (x_45 == 0)
+x_37 = !lean_is_exclusive(x_17);
+if (x_37 == 0)
 {
 return x_17;
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-x_46 = lean_ctor_get(x_17, 0);
-x_47 = lean_ctor_get(x_17, 1);
-lean_inc(x_47);
-lean_inc(x_46);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_38 = lean_ctor_get(x_17, 0);
+x_39 = lean_ctor_get(x_17, 1);
+lean_inc(x_39);
+lean_inc(x_38);
 lean_dec(x_17);
-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;
+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_49; 
+uint8_t x_41; 
 lean_dec(x_8);
 lean_dec(x_2);
 lean_dec(x_1);
-x_49 = !lean_is_exclusive(x_9);
-if (x_49 == 0)
+x_41 = !lean_is_exclusive(x_9);
+if (x_41 == 0)
 {
 return x_9;
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_50 = lean_ctor_get(x_9, 0);
-x_51 = lean_ctor_get(x_9, 1);
-lean_inc(x_51);
-lean_inc(x_50);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_9, 0);
+x_43 = lean_ctor_get(x_9, 1);
+lean_inc(x_43);
+lean_inc(x_42);
 lean_dec(x_9);
-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_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;
 }
 }
 }
@@ -13048,6 +13206,7 @@ lean_object* x_40; lean_object* x_41;
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_40 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_40, 0, x_12);
 x_41 = lean_alloc_ctor(0, 2, 0);
@@ -13069,6 +13228,7 @@ lean_dec(x_45);
 lean_inc(x_44);
 lean_inc(x_6);
 lean_inc(x_5);
+lean_inc(x_2);
 x_46 = l_Std_PersistentArray_forInAux___at_Lean_Server_FileWorker_handleDefinition___spec__5(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_42, x_44, x_13, x_14);
 lean_dec(x_42);
 if (lean_obj_tag(x_46) == 0)
@@ -13231,6 +13391,7 @@ lean_dec(x_44);
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_72 = !lean_is_exclusive(x_46);
 if (x_72 == 0)
 {
@@ -13260,6 +13421,7 @@ lean_dec(x_12);
 lean_inc(x_76);
 lean_inc(x_6);
 lean_inc(x_5);
+lean_inc(x_2);
 x_77 = l_Std_PersistentArray_forInAux___at_Lean_Server_FileWorker_handleDefinition___spec__5(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_42, x_76, x_13, x_14);
 lean_dec(x_42);
 if (lean_obj_tag(x_77) == 0)
@@ -13373,6 +13535,7 @@ lean_dec(x_76);
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_96 = lean_ctor_get(x_77, 0);
 lean_inc(x_96);
 x_97 = lean_ctor_get(x_77, 1);
@@ -13404,6 +13567,7 @@ uint8_t x_17;
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_17 = !lean_is_exclusive(x_15);
 if (x_17 == 0)
 {
@@ -13441,6 +13605,7 @@ lean_object* x_24; lean_object* x_25;
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_24 = lean_ctor_get(x_23, 0);
 lean_inc(x_24);
 lean_dec(x_23);
@@ -13477,6 +13642,7 @@ lean_object* x_31; lean_object* x_32; lean_object* x_33;
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
 lean_dec(x_30);
@@ -13872,14 +14038,6 @@ return x_115;
 }
 }
 }
-static lean_object* _init_l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string(".lean");
-return x_1;
-}
-}
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___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) {
 _start:
 {
@@ -13888,6 +14046,7 @@ x_11 = l_Lean_Expr_constName_x3f(x_7);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+lean_dec(x_6);
 lean_dec(x_2);
 x_12 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_12, 0, x_1);
@@ -13921,6 +14080,7 @@ lean_inc(x_20);
 if (lean_obj_tag(x_20) == 0)
 {
 lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+lean_dec(x_6);
 x_21 = lean_ctor_get(x_19, 1);
 lean_inc(x_21);
 lean_dec(x_19);
@@ -13933,7 +14093,7 @@ return x_23;
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
 lean_free_object(x_11);
 x_24 = lean_ctor_get(x_19, 1);
 lean_inc(x_24);
@@ -13942,12 +14102,11 @@ x_25 = lean_ctor_get(x_20, 0);
 lean_inc(x_25);
 lean_dec(x_20);
 x_26 = lean_ctor_get(x_6, 3);
-x_27 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2___closed__1;
+lean_inc(x_26);
+lean_dec(x_6);
+x_27 = l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
 x_28 = l_Lean_SearchPath_findWithExt(x_26, x_27, x_25, x_24);
 lean_dec(x_25);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; 
 x_29 = lean_ctor_get(x_28, 0);
 lean_inc(x_29);
 if (lean_obj_tag(x_29) == 0)
@@ -13993,26 +14152,29 @@ return x_41;
 }
 }
 }
+}
 else
 {
 uint8_t x_42; 
 lean_dec(x_17);
+lean_free_object(x_11);
 lean_dec(x_16);
+lean_dec(x_6);
 lean_dec(x_2);
 lean_dec(x_1);
-x_42 = !lean_is_exclusive(x_28);
+x_42 = !lean_is_exclusive(x_19);
 if (x_42 == 0)
 {
-return x_28;
+return x_19;
 }
 else
 {
 lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_28, 0);
-x_44 = lean_ctor_get(x_28, 1);
+x_43 = lean_ctor_get(x_19, 0);
+x_44 = lean_ctor_get(x_19, 1);
 lean_inc(x_44);
 lean_inc(x_43);
-lean_dec(x_28);
+lean_dec(x_19);
 x_45 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_45, 0, x_43);
 lean_ctor_set(x_45, 1, x_44);
@@ -14020,182 +14182,125 @@ return x_45;
 }
 }
 }
-}
 else
 {
-uint8_t x_46; 
-lean_dec(x_17);
-lean_free_object(x_11);
-lean_dec(x_16);
-lean_dec(x_2);
-lean_dec(x_1);
-x_46 = !lean_is_exclusive(x_19);
-if (x_46 == 0)
-{
-return x_19;
-}
-else
-{
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_47 = lean_ctor_get(x_19, 0);
-x_48 = lean_ctor_get(x_19, 1);
-lean_inc(x_48);
-lean_inc(x_47);
-lean_dec(x_19);
-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;
-}
-}
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_50 = lean_ctor_get(x_11, 0);
-lean_inc(x_50);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_46 = lean_ctor_get(x_11, 0);
+lean_inc(x_46);
 lean_dec(x_11);
-x_51 = lean_ctor_get(x_2, 0);
-lean_inc(x_51);
+x_47 = lean_ctor_get(x_2, 0);
+lean_inc(x_47);
+lean_inc(x_46);
+x_48 = lean_alloc_closure((void*)(l_Lean_findModuleOf_x3f___at_Lean_Server_FileWorker_handleDefinition___spec__1___boxed), 6, 1);
+lean_closure_set(x_48, 0, x_46);
+lean_inc(x_47);
+x_49 = l_Lean_Elab_ContextInfo_runMetaM___rarg(x_3, x_47, x_48, x_10);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; 
+x_50 = lean_ctor_get(x_49, 0);
 lean_inc(x_50);
-x_52 = lean_alloc_closure((void*)(l_Lean_findModuleOf_x3f___at_Lean_Server_FileWorker_handleDefinition___spec__1___boxed), 6, 1);
-lean_closure_set(x_52, 0, x_50);
+if (lean_obj_tag(x_50) == 0)
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+lean_dec(x_6);
+x_51 = lean_ctor_get(x_49, 1);
 lean_inc(x_51);
-x_53 = l_Lean_Elab_ContextInfo_runMetaM___rarg(x_3, x_51, x_52, x_10);
-if (lean_obj_tag(x_53) == 0)
+lean_dec(x_49);
+x_52 = lean_ctor_get(x_5, 0);
+lean_inc(x_52);
+x_53 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_53, 0, x_52);
+x_54 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__1(x_46, x_3, x_47, x_1, x_2, x_4, x_53, x_9, x_51);
+lean_dec(x_2);
+return x_54;
+}
+else
 {
-lean_object* x_54; 
-x_54 = lean_ctor_get(x_53, 0);
-lean_inc(x_54);
-if (lean_obj_tag(x_54) == 0)
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-x_55 = lean_ctor_get(x_53, 1);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_55 = lean_ctor_get(x_49, 1);
 lean_inc(x_55);
-lean_dec(x_53);
-x_56 = lean_ctor_get(x_5, 0);
+lean_dec(x_49);
+x_56 = lean_ctor_get(x_50, 0);
 lean_inc(x_56);
-x_57 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_57, 0, x_56);
-x_58 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__1(x_50, x_3, x_51, x_1, x_2, x_4, x_57, x_9, x_55);
-lean_dec(x_2);
-return x_58;
-}
-else
-{
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_59 = lean_ctor_get(x_53, 1);
-lean_inc(x_59);
-lean_dec(x_53);
-x_60 = lean_ctor_get(x_54, 0);
+lean_dec(x_50);
+x_57 = lean_ctor_get(x_6, 3);
+lean_inc(x_57);
+lean_dec(x_6);
+x_58 = l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
+x_59 = l_Lean_SearchPath_findWithExt(x_57, x_58, x_56, x_55);
+lean_dec(x_56);
+x_60 = lean_ctor_get(x_59, 0);
 lean_inc(x_60);
-lean_dec(x_54);
-x_61 = lean_ctor_get(x_6, 3);
-x_62 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2___closed__1;
-x_63 = l_Lean_SearchPath_findWithExt(x_61, x_62, x_60, x_59);
-lean_dec(x_60);
-if (lean_obj_tag(x_63) == 0)
+if (lean_obj_tag(x_60) == 0)
 {
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_63, 0);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_61 = lean_ctor_get(x_59, 1);
+lean_inc(x_61);
+lean_dec(x_59);
+x_62 = lean_box(0);
+x_63 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__1(x_46, x_3, x_47, x_1, x_2, x_4, x_62, x_9, x_61);
+lean_dec(x_2);
+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_59, 1);
 lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_65 = lean_ctor_get(x_63, 1);
+lean_dec(x_59);
+x_65 = lean_ctor_get(x_60, 0);
 lean_inc(x_65);
-lean_dec(x_63);
-x_66 = lean_box(0);
-x_67 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__1(x_50, x_3, x_51, x_1, x_2, x_4, x_66, x_9, x_65);
+if (lean_is_exclusive(x_60)) {
+ lean_ctor_release(x_60, 0);
+ x_66 = x_60;
+} else {
+ lean_dec_ref(x_60);
+ x_66 = lean_box(0);
+}
+x_67 = l_Lean_Server_toFileUri(x_65);
+if (lean_is_scalar(x_66)) {
+ x_68 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_68 = x_66;
+}
+lean_ctor_set(x_68, 0, x_67);
+x_69 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__1(x_46, x_3, x_47, x_1, x_2, x_4, x_68, x_9, x_64);
 lean_dec(x_2);
-return x_67;
+return x_69;
+}
+}
 }
 else
 {
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_68 = lean_ctor_get(x_63, 1);
-lean_inc(x_68);
-lean_dec(x_63);
-x_69 = lean_ctor_get(x_64, 0);
-lean_inc(x_69);
-if (lean_is_exclusive(x_64)) {
- lean_ctor_release(x_64, 0);
- x_70 = x_64;
-} else {
- lean_dec_ref(x_64);
- x_70 = lean_box(0);
-}
-x_71 = l_Lean_Server_toFileUri(x_69);
-if (lean_is_scalar(x_70)) {
- x_72 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_72 = x_70;
-}
-lean_ctor_set(x_72, 0, x_71);
-x_73 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__1(x_50, x_3, x_51, x_1, x_2, x_4, x_72, x_9, x_68);
+lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_47);
+lean_dec(x_46);
+lean_dec(x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+x_70 = lean_ctor_get(x_49, 0);
+lean_inc(x_70);
+x_71 = lean_ctor_get(x_49, 1);
+lean_inc(x_71);
+if (lean_is_exclusive(x_49)) {
+ lean_ctor_release(x_49, 0);
+ lean_ctor_release(x_49, 1);
+ x_72 = x_49;
+} else {
+ lean_dec_ref(x_49);
+ x_72 = lean_box(0);
+}
+if (lean_is_scalar(x_72)) {
+ x_73 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_73 = x_72;
+}
+lean_ctor_set(x_73, 0, x_70);
+lean_ctor_set(x_73, 1, x_71);
 return x_73;
 }
 }
-else
-{
-lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
-lean_dec(x_51);
-lean_dec(x_50);
-lean_dec(x_2);
-lean_dec(x_1);
-x_74 = lean_ctor_get(x_63, 0);
-lean_inc(x_74);
-x_75 = lean_ctor_get(x_63, 1);
-lean_inc(x_75);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- lean_ctor_release(x_63, 1);
- x_76 = x_63;
-} else {
- lean_dec_ref(x_63);
- x_76 = lean_box(0);
-}
-if (lean_is_scalar(x_76)) {
- x_77 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_77 = x_76;
-}
-lean_ctor_set(x_77, 0, x_74);
-lean_ctor_set(x_77, 1, x_75);
-return x_77;
-}
-}
-}
-else
-{
-lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_51);
-lean_dec(x_50);
-lean_dec(x_2);
-lean_dec(x_1);
-x_78 = lean_ctor_get(x_53, 0);
-lean_inc(x_78);
-x_79 = lean_ctor_get(x_53, 1);
-lean_inc(x_79);
-if (lean_is_exclusive(x_53)) {
- lean_ctor_release(x_53, 0);
- lean_ctor_release(x_53, 1);
- x_80 = x_53;
-} else {
- lean_dec_ref(x_53);
- x_80 = lean_box(0);
-}
-if (lean_is_scalar(x_80)) {
- x_81 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_81 = x_80;
-}
-lean_ctor_set(x_81, 0, x_78);
-lean_ctor_set(x_81, 1, x_79);
-return x_81;
-}
-}
 }
 }
 }
@@ -14218,6 +14323,7 @@ lean_object* x_39; lean_object* x_40;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_39 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_39, 0, x_11);
 x_40 = lean_alloc_ctor(0, 2, 0);
@@ -14275,6 +14381,7 @@ lean_dec(x_75);
 x_78 = lean_ctor_get(x_77, 1);
 lean_inc(x_78);
 x_79 = lean_box(0);
+lean_inc(x_2);
 lean_inc(x_6);
 x_80 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2(x_6, x_77, x_76, x_4, x_3, x_2, x_78, x_79, x_12, x_13);
 lean_dec(x_78);
@@ -14299,6 +14406,7 @@ lean_dec(x_42);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_83 = !lean_is_exclusive(x_80);
 if (x_83 == 0)
 {
@@ -14348,6 +14456,7 @@ x_96 = lean_ctor_get(x_94, 1);
 lean_inc(x_96);
 lean_dec(x_94);
 x_97 = lean_box(0);
+lean_inc(x_2);
 lean_inc(x_6);
 x_98 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2(x_6, x_88, x_87, x_4, x_3, x_2, x_95, x_97, x_12, x_96);
 lean_dec(x_95);
@@ -14372,6 +14481,7 @@ lean_dec(x_42);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_101 = !lean_is_exclusive(x_98);
 if (x_101 == 0)
 {
@@ -14402,6 +14512,7 @@ lean_dec(x_42);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_105 = !lean_is_exclusive(x_94);
 if (x_105 == 0)
 {
@@ -14608,6 +14719,7 @@ uint8_t x_16;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_16 = !lean_is_exclusive(x_14);
 if (x_16 == 0)
 {
@@ -14645,6 +14757,7 @@ lean_object* x_23; lean_object* x_24;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_23 = lean_ctor_get(x_22, 0);
 lean_inc(x_23);
 lean_dec(x_22);
@@ -14681,6 +14794,7 @@ lean_object* x_30; lean_object* x_31; lean_object* x_32;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
 lean_dec(x_29);
@@ -15131,6 +15245,7 @@ lean_object* x_39; lean_object* x_40;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_39 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_39, 0, x_11);
 x_40 = lean_alloc_ctor(0, 2, 0);
@@ -15188,6 +15303,7 @@ lean_dec(x_82);
 x_85 = lean_ctor_get(x_84, 1);
 lean_inc(x_85);
 x_86 = lean_box(0);
+lean_inc(x_2);
 lean_inc(x_6);
 x_87 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2(x_6, x_84, x_83, x_4, x_3, x_2, x_85, x_86, x_12, x_13);
 lean_dec(x_85);
@@ -15212,6 +15328,7 @@ lean_dec(x_42);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_90 = !lean_is_exclusive(x_87);
 if (x_90 == 0)
 {
@@ -15261,6 +15378,7 @@ x_103 = lean_ctor_get(x_101, 1);
 lean_inc(x_103);
 lean_dec(x_101);
 x_104 = lean_box(0);
+lean_inc(x_2);
 lean_inc(x_6);
 x_105 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2(x_6, x_95, x_94, x_4, x_3, x_2, x_102, x_104, x_12, x_103);
 lean_dec(x_102);
@@ -15285,6 +15403,7 @@ lean_dec(x_42);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_108 = !lean_is_exclusive(x_105);
 if (x_108 == 0)
 {
@@ -15315,6 +15434,7 @@ lean_dec(x_42);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_112 = !lean_is_exclusive(x_101);
 if (x_112 == 0)
 {
@@ -15560,6 +15680,7 @@ uint8_t x_16;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_16 = !lean_is_exclusive(x_14);
 if (x_16 == 0)
 {
@@ -15597,6 +15718,7 @@ lean_object* x_23; lean_object* x_24;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_23 = lean_ctor_get(x_22, 0);
 lean_inc(x_23);
 lean_dec(x_22);
@@ -15633,6 +15755,7 @@ lean_object* x_30; lean_object* x_31; lean_object* x_32;
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
 lean_dec(x_29);
@@ -15669,6 +15792,7 @@ x_11 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
 lean_inc(x_6);
 lean_inc(x_5);
+lean_inc(x_2);
 x_12 = l_Std_PersistentArray_forInAux___at_Lean_Server_FileWorker_handleDefinition___spec__5(x_1, x_2, x_3, x_4, x_5, x_6, x_8, x_11, x_8, x_9, x_10);
 lean_dec(x_8);
 if (lean_obj_tag(x_12) == 0)
@@ -15681,6 +15805,7 @@ if (lean_obj_tag(x_13) == 0)
 uint8_t x_14; 
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_14 = !lean_is_exclusive(x_12);
 if (x_14 == 0)
 {
@@ -15744,6 +15869,7 @@ if (lean_obj_tag(x_25) == 0)
 uint8_t x_26; 
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_26 = !lean_is_exclusive(x_12);
 if (x_26 == 0)
 {
@@ -15994,6 +16120,7 @@ if (lean_obj_tag(x_80) == 0)
 lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_81 = lean_ctor_get(x_12, 1);
 lean_inc(x_81);
 if (lean_is_exclusive(x_12)) {
@@ -16174,6 +16301,7 @@ else
 uint8_t x_118; 
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_2);
 x_118 = !lean_is_exclusive(x_12);
 if (x_118 == 0)
 {
@@ -16530,7 +16658,6 @@ lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_2);
 return x_18;
 }
 }
@@ -16554,7 +16681,6 @@ x_11 = l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___s
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
-lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -16576,7 +16702,6 @@ lean_dec(x_12);
 lean_dec(x_8);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_2);
 return x_17;
 }
 }
@@ -16592,7 +16717,6 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_2);
 return x_13;
 }
 }
@@ -16611,7 +16735,6 @@ lean_dec(x_12);
 lean_dec(x_8);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_2);
 return x_17;
 }
 }
@@ -16626,7 +16749,6 @@ lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_2);
 return x_12;
 }
 }
@@ -16641,7 +16763,6 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_4);
 lean_dec(x_3);
-lean_dec(x_2);
 return x_11;
 }
 }
@@ -25529,7 +25650,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Server_FileWorker_noHighlightKinds___closed__1;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__1;
 x_3 = lean_array_push(x_1, x_2);
 return x_3;
 }
@@ -28967,7 +29088,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_Server_FileWorker_handleWaitForDiagnostics___lambda__3___closed__2;
 x_2 = l_Lean_Server_FileWorker_handleWaitForDiagnostics___lambda__3___closed__3;
-x_3 = lean_unsigned_to_nat(651u);
+x_3 = lean_unsigned_to_nat(656u);
 x_4 = lean_unsigned_to_nat(26u);
 x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -38659,6 +38780,8 @@ l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5 = _init_l_Lean_Serve
 lean_mark_persistent(l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__5);
 l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6 = _init_l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6();
 lean_mark_persistent(l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__6);
+l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__7 = _init_l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__7();
+lean_mark_persistent(l_Lean_Server_FileWorker_leanpkgSetupSearchPath___closed__7);
 l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__1 = _init_l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__1();
 lean_mark_persistent(l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__1);
 l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__2 = _init_l_Lean_Server_FileWorker_compileHeader___lambda__4___closed__2();
@@ -38693,8 +38816,6 @@ l_Lean_Server_FileWorker_handleCompletion___closed__3 = _init_l_Lean_Server_File
 lean_mark_persistent(l_Lean_Server_FileWorker_handleCompletion___closed__3);
 l_Lean_Server_FileWorker_handleHover___closed__1 = _init_l_Lean_Server_FileWorker_handleHover___closed__1();
 lean_mark_persistent(l_Lean_Server_FileWorker_handleHover___closed__1);
-l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2___closed__1();
-lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___lambda__2___closed__1);
 l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___closed__1();
 lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lean_Server_FileWorker_handleDefinition___spec__7___closed__1);
 l_Lean_Server_FileWorker_handleDefinition___closed__1 = _init_l_Lean_Server_FileWorker_handleDefinition___closed__1();
diff --git a/stage0/stdlib/Lean/Server/Utils.c b/stage0/stdlib/Lean/Server/Utils.c
index 96027d30a5..c2ae6f5746 100644
--- a/stage0/stdlib/Lean/Server/Utils.c
+++ b/stage0/stdlib/Lean/Server/Utils.c
@@ -24,6 +24,7 @@ lean_object* l_IO_FS_Stream_writeLspNotification___at_Lean_Server_publishDiagnos
 uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Lean_Server_foldDocumentChanges_match__1(lean_object*);
+extern uint8_t l_System_FilePath_isCaseInsensitive;
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 lean_object* l_IO_FS_Stream_withPrefix___elambda__4(lean_object*, size_t, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Server_publishMessages___spec__3(lean_object*, size_t, size_t, lean_object*, lean_object*);
@@ -71,9 +72,9 @@ lean_object* l_IO_FS_Stream_chainLeft___elambda__2(lean_object*, lean_object*);
 extern lean_object* l_Lean_Lsp_Ipc_collectDiagnostics_loop_match__2___rarg___closed__1;
 lean_object* l_List_takeWhile_match__1(lean_object*, lean_object*);
 lean_object* l_IO_Prim_fopenFlags(uint8_t, uint8_t);
-lean_object* l_System_FilePath_normalizePath(lean_object*);
 lean_object* l_IO_FS_Stream_writeLspMessage(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_FS_Stream_chainLeft___elambda__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_normalize(lean_object*, uint8_t);
 lean_object* l_IO_FS_Stream_chainRight___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Server_publishMessages___spec__4(lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Json_toStructured_x3f___at_Lean_Server_publishDiagnostics___spec__2(lean_object*);
@@ -1529,32 +1530,33 @@ return x_1;
 lean_object* l_Lean_Server_toFileUri(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; uint8_t x_3; 
-x_2 = l_System_FilePath_normalizePath(x_1);
-x_3 = l_System_Platform_isWindows;
-if (x_3 == 0)
+uint8_t x_2; lean_object* x_3; uint8_t x_4; 
+x_2 = l_System_FilePath_isCaseInsensitive;
+x_3 = l_System_FilePath_normalize(x_1, x_2);
+x_4 = l_System_Platform_isWindows;
+if (x_4 == 0)
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_4 = l_Lean_Server_toFileUri___closed__1;
-x_5 = l_String_dropWhile(x_2, x_4);
-lean_dec(x_2);
-x_6 = l_Lean_Server_toFileUri___closed__2;
-x_7 = lean_string_append(x_6, x_5);
-lean_dec(x_5);
-return x_7;
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = l_Lean_Server_toFileUri___closed__1;
+x_6 = l_String_dropWhile(x_3, x_5);
+lean_dec(x_3);
+x_7 = l_Lean_Server_toFileUri___closed__2;
+x_8 = lean_string_append(x_7, x_6);
+lean_dec(x_6);
+return x_8;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_8 = lean_unsigned_to_nat(0u);
-x_9 = l_String_mapAux___at_Lean_Server_toFileUri___spec__1(x_8, x_2);
-x_10 = l_Lean_Server_toFileUri___closed__1;
-x_11 = l_String_dropWhile(x_9, x_10);
-lean_dec(x_9);
-x_12 = l_Lean_Server_toFileUri___closed__2;
-x_13 = lean_string_append(x_12, x_11);
-lean_dec(x_11);
-return x_13;
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_9 = lean_unsigned_to_nat(0u);
+x_10 = l_String_mapAux___at_Lean_Server_toFileUri___spec__1(x_9, x_3);
+x_11 = l_Lean_Server_toFileUri___closed__1;
+x_12 = l_String_dropWhile(x_10, x_11);
+lean_dec(x_10);
+x_13 = l_Lean_Server_toFileUri___closed__2;
+x_14 = lean_string_append(x_13, x_12);
+lean_dec(x_12);
+return x_14;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Server/Watchdog.c b/stage0/stdlib/Lean/Server/Watchdog.c
index 441c42fafa..dc614dc70e 100644
--- a/stage0/stdlib/Lean/Server/Watchdog.c
+++ b/stage0/stdlib/Lean/Server/Watchdog.c
@@ -29,6 +29,7 @@ lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Server_Watchdog_startFileWorker___closed__8;
 lean_object* lean_io_mono_ms_now(lean_object*);
 lean_object* l___private_Lean_Data_Lsp_TextSync_0__Lean_Lsp_fromJsonDidOpenTextDocumentParams____x40_Lean_Data_Lsp_TextSync___hyg_100_(lean_object*);
+lean_object* l_System_FilePath_join(lean_object*, lean_object*);
 lean_object* l_Lean_Server_Watchdog_handleDidOpen(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Char_quote___closed__1;
 lean_object* l_Lean_Server_Watchdog_handleRequest___closed__1;
@@ -160,6 +161,7 @@ lean_object* l_Std_RBNode_find___at_Lean_Server_Watchdog_findFileWorker___spec__
 lean_object* l_IO_mkRef___at_Lean_Server_Watchdog_startFileWorker___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_forIn_visit___at_Lean_Server_Watchdog_shutdown___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_Watchdog_parseParams___at_Lean_Server_Watchdog_handleNotification___spec__3(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
 extern lean_object* l_Lean_Parser_Command_initialize___elambda__1___closed__1;
 extern lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_298____closed__4;
 lean_object* l_Lean_Server_Watchdog_runClientTask___closed__1;
@@ -277,6 +279,7 @@ lean_object* l___private_Lean_Server_Watchdog_0__Lean_Server_Watchdog_forwardMes
 lean_object* l_Lean_Server_Watchdog_tryWriteMessage(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Server_publishDiagnostics(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializeParams___spec__5(lean_object*, lean_object*);
+extern lean_object* l_System_FilePath_exeExtension;
 lean_object* l_IO_FS_Stream_writeLspNotification___at_Lean_Server_Watchdog_startFileWorker___spec__5(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_toStructured_x3f___at_Lean_Server_Watchdog_handleEdits___spec__1(lean_object*);
 lean_object* l_IO_FS_Stream_readRequestAs___at_Lean_Server_Watchdog_initAndRunWatchdog___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -402,12 +405,12 @@ lean_object* l_Lean_Server_maybeTee(lean_object*, uint8_t, lean_object*, lean_ob
 lean_object* lean_io_app_dir(lean_object*);
 lean_object* l_Lean_Server_Watchdog_mkLeanServerCapabilities___closed__1;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Server_Watchdog_tryWriteMessage___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_withExtension(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_forIn_visit___at_Lean_Server_Watchdog_FileWorker_errorPendingRequests___spec__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_Watchdog_parseParams___at_Lean_Server_Watchdog_handleRequest___spec__10(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_toStructured_x3f___at_Lean_Server_Watchdog_handleRequest___spec__2(lean_object*);
 extern lean_object* l_Lean_JsonRpc_instToJsonMessage___closed__13;
 lean_object* l_Lean_Server_Watchdog_parseParams___at_Lean_Server_Watchdog_handleRequest___spec__6(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_System_FilePath_exeSuffix;
 lean_object* l_Lean_Server_Watchdog_handleCancelRequest(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_Watchdog_tryWriteMessage___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_Watchdog_log(lean_object*, lean_object*, lean_object*);
@@ -418,7 +421,6 @@ extern lean_object* l_Lean_JsonRpc_instToJsonErrorCode___closed__12;
 lean_object* l_Lean_Server_Watchdog_initAndRunWatchdogAux_match__1(lean_object*);
 lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_298_(lean_object*);
 lean_object* l___private_Lean_Server_Watchdog_0__Lean_Server_Watchdog_forwardMessages_loop___closed__6;
-extern lean_object* l_Lean_getBuiltinSearchPath___closed__3;
 extern lean_object* l_Lean_JsonRpc_instToJsonMessage___closed__9;
 lean_object* l_Lean_Server_Watchdog_handleEdits___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_Watchdog_initAndRunWatchdog___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -5391,7 +5393,7 @@ lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean
 x_50 = lean_ctor_get(x_49, 1);
 lean_inc(x_50);
 lean_dec(x_49);
-x_51 = l_Lean_getBuiltinSearchPath___closed__3;
+x_51 = l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
 x_52 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_52, 0, x_9);
 lean_ctor_set(x_52, 1, x_51);
@@ -19520,7 +19522,7 @@ static lean_object* _init_l_Lean_Server_Watchdog_initAndRunWatchdog___closed__2(
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("/bin/lean");
+x_1 = lean_mk_string("bin");
 return x_1;
 }
 }
@@ -19556,7 +19558,7 @@ return x_14;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
 lean_dec(x_7);
 x_15 = lean_ctor_get(x_10, 1);
 lean_inc(x_15);
@@ -19564,71 +19566,69 @@ lean_dec(x_10);
 x_16 = lean_ctor_get(x_11, 0);
 lean_inc(x_16);
 lean_dec(x_11);
-x_17 = l_Lean_instInhabitedParserDescr___closed__1;
-x_18 = lean_string_append(x_17, x_16);
-lean_dec(x_16);
-x_19 = l_Lean_Server_Watchdog_initAndRunWatchdog___closed__2;
-x_20 = lean_string_append(x_18, x_19);
-x_21 = l_System_FilePath_exeSuffix;
-x_22 = lean_string_append(x_20, x_21);
-x_23 = lean_string_append(x_22, x_17);
-x_24 = lean_box(0);
-x_25 = l_Lean_Server_Watchdog_initAndRunWatchdog___lambda__2(x_2, x_3, x_4, x_1, x_23, x_24, x_15);
-return x_25;
+x_17 = l_Lean_Server_Watchdog_initAndRunWatchdog___closed__2;
+x_18 = l_System_FilePath_join(x_16, x_17);
+x_19 = l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
+x_20 = l_System_FilePath_join(x_18, x_19);
+x_21 = l_System_FilePath_exeExtension;
+x_22 = l_System_FilePath_withExtension(x_20, x_21);
+x_23 = lean_box(0);
+x_24 = l_Lean_Server_Watchdog_initAndRunWatchdog___lambda__2(x_2, x_3, x_4, x_1, x_22, x_23, x_15);
+return x_24;
 }
 }
 else
 {
-uint8_t x_26; 
+uint8_t x_25; 
 lean_dec(x_7);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_26 = !lean_is_exclusive(x_10);
-if (x_26 == 0)
+x_25 = !lean_is_exclusive(x_10);
+if (x_25 == 0)
 {
 return x_10;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_27 = lean_ctor_get(x_10, 0);
-x_28 = lean_ctor_get(x_10, 1);
-lean_inc(x_28);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_26 = lean_ctor_get(x_10, 0);
+x_27 = lean_ctor_get(x_10, 1);
 lean_inc(x_27);
+lean_inc(x_26);
 lean_dec(x_10);
-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;
+x_28 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_28, 0, x_26);
+lean_ctor_set(x_28, 1, x_27);
+return x_28;
 }
 }
 }
 else
 {
-uint8_t x_30; 
+uint8_t x_29; 
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_30 = !lean_is_exclusive(x_6);
-if (x_30 == 0)
+x_29 = !lean_is_exclusive(x_6);
+if (x_29 == 0)
 {
 return x_6;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_31 = lean_ctor_get(x_6, 0);
-x_32 = lean_ctor_get(x_6, 1);
-lean_inc(x_32);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_30 = lean_ctor_get(x_6, 0);
+x_31 = lean_ctor_get(x_6, 1);
 lean_inc(x_31);
+lean_inc(x_30);
 lean_dec(x_6);
-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;
+x_32 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_32, 0, x_30);
+lean_ctor_set(x_32, 1, x_31);
+return x_32;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/ToExpr.c b/stage0/stdlib/Lean/ToExpr.c
index aaf08a0817..6571ceac14 100644
--- a/stage0/stdlib/Lean/ToExpr.c
+++ b/stage0/stdlib/Lean/ToExpr.c
@@ -62,6 +62,7 @@ extern lean_object* l___private_Init_Meta_0__Lean_quoteOption___rarg___closed__2
 lean_object* l_Lean_Name_toExprAux(lean_object*);
 extern lean_object* l_Lean_instQuoteBool___closed__3;
 lean_object* l_Lean_Name_toExprAux_match__1(lean_object*);
+extern lean_object* l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 lean_object* lean_array_to_list(lean_object*, lean_object*);
 extern lean_object* l_Lean_Literal_type___closed__4;
 lean_object* l_Lean_instToExprUnit___lambda__1___closed__3;
@@ -73,7 +74,6 @@ extern lean_object* l___private_Init_Meta_0__Lean_quoteNameMk___closed__7;
 lean_object* l_Lean_instToExprBool___lambda__1___closed__1;
 lean_object* l_Lean_instToExprBool___lambda__1___boxed(lean_object*);
 lean_object* l_Lean_instToExprOption___rarg___lambda__1___closed__3;
-extern lean_object* l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_11086____closed__5;
 lean_object* l_Lean_instToExprUnit___lambda__1___closed__2;
 lean_object* l_Lean_instToExprBool;
@@ -395,7 +395,7 @@ static lean_object* _init_l_Lean_instToExprUnit___lambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_System_IO___hyg_3180____closed__17;
+x_1 = l_myMacro____x40_Init_System_IO___hyg_4276____closed__17;
 x_2 = l_Lean_instToExprUnit___lambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
diff --git a/stage0/stdlib/Lean/Util/Path.c b/stage0/stdlib/Lean/Util/Path.c
index a0a4630381..3048a2fdf7 100644
--- a/stage0/stdlib/Lean/Util/Path.c
+++ b/stage0/stdlib/Lean/Util/Path.c
@@ -13,122 +13,109 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Lean_moduleNameOfFileName___lambda__2(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_getBuiltinSearchPath___closed__6;
+lean_object* l_Lean_moduleNameOfFileName___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_modToFilePath_go___closed__2;
+lean_object* l_Lean_moduleNameOfFileName___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_modToFilePath_go___closed__4;
 lean_object* l_Lean_findOLean___closed__3;
-extern lean_object* l_String_instInhabitedString;
+lean_object* l_Lean_modToFilePath_go___closed__1;
+lean_object* l_System_FilePath_join(lean_object*, lean_object*);
 extern lean_object* l_Char_quote___closed__1;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
-lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* lean_io_is_dir(lean_object*, lean_object*);
-lean_object* l_String_revPosOf(lean_object*, uint32_t);
-lean_object* l_Lean_modPathToFilePath_match__1(lean_object*);
+lean_object* l_Lean_modToFilePath_go___boxed(lean_object*, lean_object*);
+extern uint8_t l_System_FilePath_isCaseInsensitive;
 lean_object* l_Lean_SearchPath_findWithExt___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_getBuiltinSearchPath___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_searchPathRef;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedParserDescr___closed__1;
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
+lean_object* l_System_FilePath_components(lean_object*);
 lean_object* l_Lean_addSearchPathFromEnv_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath(lean_object*);
-lean_object* l_Lean_parseSearchPath___boxed(lean_object*, lean_object*);
-lean_object* l_IO_isDir___at_Lean_SearchPath_findWithExt___spec__1___boxed(lean_object*, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
-lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_modToFilePath_go(lean_object*, lean_object*);
+lean_object* l_Lean_moduleNameOfFileName___lambda__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_getEnv___at_Lean_addSearchPathFromEnv___spec__1___boxed(lean_object*, lean_object*);
-lean_object* l_String_splitOn(lean_object*, lean_object*);
+lean_object* l_Lean_modToFilePath_go_match__1(lean_object*);
 lean_object* lean_io_getenv(lean_object*, lean_object*);
-lean_object* l_IO_mkRef___at_Lean_initFn____x40_Lean_Util_Path___hyg_203____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_moduleNameOfFileName___lambda__2___closed__1;
 lean_object* l_Lean_moduleNameOfFileName_match__1(lean_object*);
 lean_object* l_Lean_findOLean(lean_object*, lean_object*);
+lean_object* l_Lean_modToFilePath___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_pathExists(lean_object*, lean_object*);
 extern lean_object* l_Lean_Syntax_formatStxAux___closed__3;
 lean_object* l_Lean_findOLean_maybeThisOne___closed__2;
+lean_object* l_Lean_findOLean_match__1(lean_object*);
 lean_object* l_Lean_findOLean_maybeThisOne___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
 lean_object* l_Lean_moduleNameOfFileName___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_current_dir(lean_object*);
-uint8_t l_Lean_getBuiltinSearchPath___closed__1;
+lean_object* l_Lean_getBuiltinSearchPath___closed__1;
 lean_object* l_Lean_moduleNameOfFileName___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_moduleNameOfFileName___lambda__1___closed__1;
 lean_object* l_Lean_Name_toString(lean_object*, uint8_t);
 lean_object* l_IO_currentDir___at_Lean_findOLean___spec__1(lean_object*);
+extern lean_object* l_System_instInhabitedFilePath;
 lean_object* l_Lean_addSearchPathFromEnv___closed__1;
-lean_object* l_IO_fileExists___at_Lean_SearchPath_findWithExt___spec__2___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_modPathToFilePath___closed__4;
-lean_object* l_Lean_moduleNameOfFileName___lambda__1___closed__2;
+lean_object* l_Lean_modToFilePath_go___closed__3;
 lean_object* lean_io_realpath(lean_object*, lean_object*);
-lean_object* l_Lean_modPathToFilePath___closed__1;
 lean_object* l___private_Lean_Util_Path_0__Lean_isStage0___boxed(lean_object*);
 lean_object* l_List_foldl___at_Lean_moduleNameOfFileName___spec__1(lean_object*, lean_object*);
-lean_object* l_System_FilePath_normalizePath(lean_object*);
-lean_object* l_Lean_getBuiltinSearchPath___closed__5;
 lean_object* l_Lean_findOLean___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
-lean_object* l_Lean_modPathToFilePath___closed__2;
-lean_object* l_Lean_initFn____x40_Lean_Util_Path___hyg_203_(lean_object*);
+lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_System_FilePath_normalize(lean_object*, uint8_t);
+lean_object* l_Lean_initFn____x40_Lean_Util_Path___hyg_164_(lean_object*);
+uint8_t l_String_endsWith(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean___closed__2;
-lean_object* l_Lean_modPathToFilePath___boxed(lean_object*);
 lean_object* l_Lean_SearchPath_findWithExt(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_moduleNameOfFileName_match__1___rarg(lean_object*, lean_object*, lean_object*);
-extern uint32_t l_System_FilePath_pathSeparator;
-uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 lean_object* lean_module_name_of_file(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_appDir___at_Lean_getBuiltinSearchPath___spec__1(lean_object*);
-lean_object* l_Lean_modPathToFilePath___closed__3;
 lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_realPathNormalized(lean_object*, lean_object*);
-lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_IO_mkRef___at_Lean_initFn____x40_Lean_Util_Path___hyg_164____spec__1(lean_object*, lean_object*);
 lean_object* l_IO_getEnv___at_Lean_addSearchPathFromEnv___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_initSearchPath_match__1(lean_object*);
 lean_object* lean_init_search_path(lean_object*, lean_object*);
 lean_object* l_Lean_addSearchPathFromEnv_match__1(lean_object*);
 lean_object* l_Lean_findOLean___closed__1;
-lean_object* lean_io_file_exists(lean_object*, lean_object*);
-uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 lean_object* l_Lean_findOLean___boxed(lean_object*, lean_object*);
-lean_object* l_IO_isDir___at_Lean_SearchPath_findWithExt___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean_maybeThisOne_match__1(lean_object*);
 uint8_t l_String_isPrefixOf(lean_object*, lean_object*);
-lean_object* l_Lean_modPathToFilePath_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_modToFilePath_go_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_IO_appDir___rarg___lambda__1___closed__1;
 lean_object* lean_panic_fn(lean_object*, lean_object*);
 lean_object* l_Lean_addSearchPathFromEnv(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean_maybeThisOne_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_getBuiltinSearchPath___closed__2;
-lean_object* l_Lean_moduleNameOfFileName_match__2___rarg(lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_getBuiltinSearchPath___closed__2;
+lean_object* l_Lean_findOLean_maybeThisOne___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_findOLean_maybeThisOne___closed__1;
-lean_object* l_IO_fileExists___at_Lean_SearchPath_findWithExt___spec__2(lean_object*, lean_object*);
-lean_object* l_Lean_getBuiltinSearchPath___closed__4;
-extern lean_object* l_System_mkFilePath___closed__1;
+lean_object* l_System_FilePath_isDir(lean_object*, lean_object*);
+lean_object* l_Lean_modToFilePath(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_findOLean_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_getBuiltinSearchPath___closed__7;
 lean_object* l_Lean_initSearchPath_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_parseSearchPath(lean_object*, lean_object*);
 uint8_t l___private_Lean_Util_Path_0__Lean_isStage0(lean_object*);
 lean_object* l_IO_appPath___at_Lean_getBuiltinSearchPath___spec__2(lean_object*);
 lean_object* l_Lean_moduleNameOfFileName___lambda__2___closed__2;
-lean_object* l_Lean_moduleNameOfFileName_match__2(lean_object*);
+lean_object* l_Lean_getBuiltinSearchPath___lambda__1___closed__1;
+lean_object* l_Lean_getBuiltinSearchPath___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_System_SearchPath_parse(lean_object*);
 extern lean_object* l_prec_x28___x29___closed__7;
 lean_object* lean_string_length(lean_object*);
 lean_object* l_System_FilePath_parent(lean_object*);
-lean_object* l_Lean_modPathToFilePath(lean_object*);
 lean_object* lean_io_app_dir(lean_object*);
+lean_object* l_System_FilePath_withExtension(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean_maybeThisOne(lean_object*, lean_object*, lean_object*);
 lean_object* l_String_drop(lean_object*, lean_object*);
+lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_getRoot(lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath___closed__3;
-lean_object* l_String_split___at_System_FilePath_splitSearchPath___spec__1(lean_object*);
-lean_object* l___private_Lean_Util_Path_0__Lean_pathSep;
+extern lean_object* l_System_FilePath_join___closed__1;
 lean_object* l_IO_realPath___at_Lean_realPathNormalized___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean_maybeThisOne___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* _init_l___private_Lean_Util_Path_0__Lean_pathSep() {
-_start:
-{
-lean_object* x_1; 
-x_1 = l_System_mkFilePath___closed__1;
-return x_1;
-}
-}
 lean_object* l_IO_realPath___at_Lean_realPathNormalized___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -148,52 +135,54 @@ uint8_t x_4;
 x_4 = !lean_is_exclusive(x_3);
 if (x_4 == 0)
 {
-lean_object* x_5; lean_object* x_6; 
+lean_object* x_5; uint8_t x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_3, 0);
-x_6 = l_System_FilePath_normalizePath(x_5);
-lean_ctor_set(x_3, 0, x_6);
+x_6 = l_System_FilePath_isCaseInsensitive;
+x_7 = l_System_FilePath_normalize(x_5, x_6);
+lean_ctor_set(x_3, 0, x_7);
 return x_3;
 }
 else
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_3, 0);
-x_8 = lean_ctor_get(x_3, 1);
+lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; 
+x_8 = lean_ctor_get(x_3, 0);
+x_9 = lean_ctor_get(x_3, 1);
+lean_inc(x_9);
 lean_inc(x_8);
-lean_inc(x_7);
 lean_dec(x_3);
-x_9 = l_System_FilePath_normalizePath(x_7);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_9);
-lean_ctor_set(x_10, 1, x_8);
-return x_10;
+x_10 = l_System_FilePath_isCaseInsensitive;
+x_11 = l_System_FilePath_normalize(x_8, x_10);
+x_12 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_12, 0, x_11);
+lean_ctor_set(x_12, 1, x_9);
+return x_12;
 }
 }
 else
 {
-uint8_t x_11; 
-x_11 = !lean_is_exclusive(x_3);
-if (x_11 == 0)
+uint8_t x_13; 
+x_13 = !lean_is_exclusive(x_3);
+if (x_13 == 0)
 {
 return x_3;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_12 = lean_ctor_get(x_3, 0);
-x_13 = lean_ctor_get(x_3, 1);
-lean_inc(x_13);
-lean_inc(x_12);
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_14 = lean_ctor_get(x_3, 0);
+x_15 = lean_ctor_get(x_3, 1);
+lean_inc(x_15);
+lean_inc(x_14);
 lean_dec(x_3);
-x_14 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_14, 0, x_12);
-lean_ctor_set(x_14, 1, x_13);
-return x_14;
+x_16 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_16, 0, x_14);
+lean_ctor_set(x_16, 1, x_15);
+return x_16;
 }
 }
 }
 }
-lean_object* l_Lean_modPathToFilePath_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_modToFilePath_go_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -239,15 +228,15 @@ return x_16;
 }
 }
 }
-lean_object* l_Lean_modPathToFilePath_match__1(lean_object* x_1) {
+lean_object* l_Lean_modToFilePath_go_match__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_modPathToFilePath_match__1___rarg), 4, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_modToFilePath_go_match__1___rarg), 4, 0);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_modPathToFilePath___closed__1() {
+static lean_object* _init_l_Lean_modToFilePath_go___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -255,15 +244,15 @@ x_1 = lean_mk_string("Lean.Util.Path");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_modPathToFilePath___closed__2() {
+static lean_object* _init_l_Lean_modToFilePath_go___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("Lean.modPathToFilePath");
+x_1 = lean_mk_string("Lean.modToFilePath.go");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_modPathToFilePath___closed__3() {
+static lean_object* _init_l_Lean_modToFilePath_go___closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -271,77 +260,79 @@ x_1 = lean_mk_string("ill-formed import");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_modPathToFilePath___closed__4() {
+static lean_object* _init_l_Lean_modToFilePath_go___closed__4() {
 _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_modPathToFilePath___closed__1;
-x_2 = l_Lean_modPathToFilePath___closed__2;
-x_3 = lean_unsigned_to_nat(24u);
-x_4 = lean_unsigned_to_nat(35u);
-x_5 = l_Lean_modPathToFilePath___closed__3;
+x_1 = l_Lean_modToFilePath_go___closed__1;
+x_2 = l_Lean_modToFilePath_go___closed__2;
+x_3 = lean_unsigned_to_nat(25u);
+x_4 = lean_unsigned_to_nat(22u);
+x_5 = l_Lean_modToFilePath_go___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_modPathToFilePath(lean_object* x_1) {
+lean_object* l_Lean_modToFilePath_go(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-switch (lean_obj_tag(x_1)) {
+switch (lean_obj_tag(x_2)) {
 case 0:
 {
-lean_object* x_2; 
-x_2 = l_Lean_instInhabitedParserDescr___closed__1;
-return x_2;
+lean_inc(x_1);
+return x_1;
 }
 case 1:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_3 = lean_ctor_get(x_1, 0);
-x_4 = lean_ctor_get(x_1, 1);
-x_5 = l_Lean_modPathToFilePath(x_3);
-x_6 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_7 = lean_string_append(x_5, x_6);
-x_8 = lean_string_append(x_7, x_4);
-return x_8;
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_3 = lean_ctor_get(x_2, 0);
+x_4 = lean_ctor_get(x_2, 1);
+x_5 = l_Lean_modToFilePath_go(x_1, x_3);
+x_6 = l_System_FilePath_join(x_5, x_4);
+return x_6;
 }
 default: 
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_9 = l_String_instInhabitedString;
-x_10 = l_Lean_modPathToFilePath___closed__4;
-x_11 = lean_panic_fn(x_9, x_10);
-return x_11;
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_7 = l_System_instInhabitedFilePath;
+x_8 = l_Lean_modToFilePath_go___closed__4;
+x_9 = lean_panic_fn(x_7, x_8);
+return x_9;
 }
 }
 }
 }
-lean_object* l_Lean_modPathToFilePath___boxed(lean_object* x_1) {
+lean_object* l_Lean_modToFilePath_go___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_2; 
-x_2 = l_Lean_modPathToFilePath(x_1);
+lean_object* x_3; 
+x_3 = l_Lean_modToFilePath_go(x_1, x_2);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_IO_isDir___at_Lean_SearchPath_findWithExt___spec__1(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_io_is_dir(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_IO_fileExists___at_Lean_SearchPath_findWithExt___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_modToFilePath(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_io_file_exists(x_1, x_2);
-return x_3;
+lean_object* x_4; lean_object* x_5; 
+x_4 = l_Lean_modToFilePath_go(x_1, x_2);
+x_5 = l_System_FilePath_withExtension(x_4, x_3);
+return x_5;
 }
 }
-lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_modToFilePath___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_modToFilePath(x_1, x_2, x_3);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -355,159 +346,101 @@ return x_6;
 }
 else
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
 x_7 = lean_ctor_get(x_3, 0);
+lean_inc(x_7);
 x_8 = lean_ctor_get(x_3, 1);
-x_9 = l_Lean_instInhabitedParserDescr___closed__1;
-x_10 = lean_string_append(x_9, x_7);
-x_11 = lean_string_append(x_10, x_9);
-x_12 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_13 = lean_string_append(x_11, x_12);
-x_14 = lean_string_append(x_13, x_9);
-x_15 = lean_string_append(x_14, x_2);
-x_16 = lean_string_append(x_15, x_9);
-x_17 = lean_io_is_dir(x_16, x_4);
-if (lean_obj_tag(x_17) == 0)
+lean_inc(x_8);
+lean_dec(x_3);
+lean_inc(x_7);
+x_9 = l_System_FilePath_join(x_7, x_2);
+x_10 = l_System_FilePath_isDir(x_9, x_4);
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+x_12 = lean_unbox(x_11);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_18; uint8_t x_19; 
-x_18 = lean_ctor_get(x_17, 0);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_13 = lean_ctor_get(x_10, 1);
+lean_inc(x_13);
+lean_dec(x_10);
+x_14 = l_System_FilePath_withExtension(x_9, x_1);
+x_15 = l_System_FilePath_pathExists(x_14, x_13);
+lean_dec(x_14);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_unbox(x_16);
+lean_dec(x_16);
+if (x_17 == 0)
+{
+lean_object* x_18; 
+lean_dec(x_7);
+x_18 = lean_ctor_get(x_15, 1);
 lean_inc(x_18);
-x_19 = lean_unbox(x_18);
-lean_dec(x_18);
-if (x_19 == 0)
-{
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_20 = lean_ctor_get(x_17, 1);
-lean_inc(x_20);
-lean_dec(x_17);
-x_21 = lean_string_append(x_16, x_1);
-x_22 = lean_string_append(x_21, x_9);
-x_23 = lean_io_file_exists(x_22, x_20);
-lean_dec(x_22);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; uint8_t x_25; 
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_unbox(x_24);
-lean_dec(x_24);
-if (x_25 == 0)
-{
-lean_object* x_26; 
-x_26 = lean_ctor_get(x_23, 1);
-lean_inc(x_26);
-lean_dec(x_23);
+lean_dec(x_15);
 x_3 = x_8;
-x_4 = x_26;
+x_4 = x_18;
 goto _start;
 }
 else
 {
-uint8_t x_28; 
-x_28 = !lean_is_exclusive(x_23);
-if (x_28 == 0)
+uint8_t x_20; 
+lean_dec(x_8);
+x_20 = !lean_is_exclusive(x_15);
+if (x_20 == 0)
 {
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_23, 0);
-lean_dec(x_29);
-lean_inc(x_7);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_15, 0);
+lean_dec(x_21);
+x_22 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_22, 0, x_7);
+lean_ctor_set(x_15, 0, x_22);
+return x_15;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_23 = lean_ctor_get(x_15, 1);
+lean_inc(x_23);
+lean_dec(x_15);
+x_24 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_24, 0, x_7);
+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_9);
+lean_dec(x_8);
+x_26 = !lean_is_exclusive(x_10);
+if (x_26 == 0)
+{
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_ctor_get(x_10, 0);
+lean_dec(x_27);
+x_28 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_28, 0, x_7);
+lean_ctor_set(x_10, 0, x_28);
+return x_10;
+}
+else
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_29 = lean_ctor_get(x_10, 1);
+lean_inc(x_29);
+lean_dec(x_10);
 x_30 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_30, 0, x_7);
-lean_ctor_set(x_23, 0, x_30);
-return x_23;
-}
-else
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_31 = lean_ctor_get(x_23, 1);
-lean_inc(x_31);
-lean_dec(x_23);
-lean_inc(x_7);
-x_32 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_32, 0, x_7);
-x_33 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_31);
-return x_33;
-}
-}
-}
-else
-{
-uint8_t x_34; 
-x_34 = !lean_is_exclusive(x_23);
-if (x_34 == 0)
-{
-return x_23;
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_23, 0);
-x_36 = lean_ctor_get(x_23, 1);
-lean_inc(x_36);
-lean_inc(x_35);
-lean_dec(x_23);
-x_37 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_36);
-return x_37;
-}
-}
-}
-else
-{
-uint8_t x_38; 
-lean_dec(x_16);
-x_38 = !lean_is_exclusive(x_17);
-if (x_38 == 0)
-{
-lean_object* x_39; lean_object* x_40; 
-x_39 = lean_ctor_get(x_17, 0);
-lean_dec(x_39);
-lean_inc(x_7);
-x_40 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_40, 0, x_7);
-lean_ctor_set(x_17, 0, x_40);
-return x_17;
-}
-else
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_41 = lean_ctor_get(x_17, 1);
-lean_inc(x_41);
-lean_dec(x_17);
-lean_inc(x_7);
-x_42 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_42, 0, x_7);
-x_43 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_43, 0, x_42);
-lean_ctor_set(x_43, 1, x_41);
-return x_43;
-}
-}
-}
-else
-{
-uint8_t x_44; 
-lean_dec(x_16);
-x_44 = !lean_is_exclusive(x_17);
-if (x_44 == 0)
-{
-return x_17;
-}
-else
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-x_45 = lean_ctor_get(x_17, 0);
-x_46 = lean_ctor_get(x_17, 1);
-lean_inc(x_46);
-lean_inc(x_45);
-lean_dec(x_17);
-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;
+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;
 }
 }
 }
@@ -516,15 +449,12 @@ return x_47;
 lean_object* l_Lean_SearchPath_findWithExt(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; 
+lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
 x_5 = l_Lean_Name_getRoot(x_3);
 x_6 = 1;
 x_7 = l_Lean_Name_toString(x_5, x_6);
-x_8 = l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__3(x_2, x_7, x_1, x_4);
+x_8 = l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__1(x_2, x_7, x_1, x_4);
 lean_dec(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);
 if (lean_obj_tag(x_9) == 0)
@@ -565,111 +495,63 @@ lean_dec(x_17);
 x_18 = !lean_is_exclusive(x_9);
 if (x_18 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_object* x_19; lean_object* x_20; 
 x_19 = lean_ctor_get(x_9, 0);
-x_20 = l_Lean_modPathToFilePath(x_3);
-x_21 = lean_string_append(x_19, x_20);
-lean_dec(x_20);
-x_22 = lean_string_append(x_21, x_2);
-lean_ctor_set(x_9, 0, x_22);
+x_20 = l_Lean_modToFilePath(x_19, x_3, x_2);
+lean_dec(x_19);
+lean_ctor_set(x_9, 0, x_20);
 return x_8;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_23 = lean_ctor_get(x_9, 0);
-lean_inc(x_23);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_9, 0);
+lean_inc(x_21);
 lean_dec(x_9);
-x_24 = l_Lean_modPathToFilePath(x_3);
-x_25 = lean_string_append(x_23, x_24);
-lean_dec(x_24);
-x_26 = lean_string_append(x_25, x_2);
-x_27 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_27, 0, x_26);
-lean_ctor_set(x_8, 0, x_27);
+x_22 = l_Lean_modToFilePath(x_21, x_3, x_2);
+lean_dec(x_21);
+x_23 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_23, 0, x_22);
+lean_ctor_set(x_8, 0, x_23);
 return x_8;
 }
 }
 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; 
-x_28 = lean_ctor_get(x_8, 1);
-lean_inc(x_28);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_24 = lean_ctor_get(x_8, 1);
+lean_inc(x_24);
 lean_dec(x_8);
-x_29 = lean_ctor_get(x_9, 0);
-lean_inc(x_29);
+x_25 = lean_ctor_get(x_9, 0);
+lean_inc(x_25);
 if (lean_is_exclusive(x_9)) {
  lean_ctor_release(x_9, 0);
- x_30 = x_9;
+ x_26 = x_9;
 } else {
  lean_dec_ref(x_9);
- x_30 = lean_box(0);
+ x_26 = lean_box(0);
 }
-x_31 = l_Lean_modPathToFilePath(x_3);
-x_32 = lean_string_append(x_29, x_31);
-lean_dec(x_31);
-x_33 = lean_string_append(x_32, x_2);
-if (lean_is_scalar(x_30)) {
- x_34 = lean_alloc_ctor(1, 1, 0);
+x_27 = l_Lean_modToFilePath(x_25, x_3, x_2);
+lean_dec(x_25);
+if (lean_is_scalar(x_26)) {
+ x_28 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_34 = x_30;
+ x_28 = x_26;
 }
-lean_ctor_set(x_34, 0, x_33);
-x_35 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_35, 1, x_28);
-return x_35;
-}
-}
-}
-else
-{
-uint8_t x_36; 
-x_36 = !lean_is_exclusive(x_8);
-if (x_36 == 0)
-{
-return x_8;
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_37 = lean_ctor_get(x_8, 0);
-x_38 = lean_ctor_get(x_8, 1);
-lean_inc(x_38);
-lean_inc(x_37);
-lean_dec(x_8);
-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;
+lean_ctor_set(x_28, 0, x_27);
+x_29 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_29, 0, x_28);
+lean_ctor_set(x_29, 1, x_24);
+return x_29;
 }
 }
 }
 }
-lean_object* l_IO_isDir___at_Lean_SearchPath_findWithExt___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_IO_isDir___at_Lean_SearchPath_findWithExt___spec__1(x_1, x_2);
-lean_dec(x_1);
-return x_3;
-}
-}
-lean_object* l_IO_fileExists___at_Lean_SearchPath_findWithExt___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_IO_fileExists___at_Lean_SearchPath_findWithExt___spec__2(x_1, x_2);
-lean_dec(x_1);
-return x_3;
-}
-}
-lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__3(x_1, x_2, x_3, x_4);
-lean_dec(x_3);
+x_5 = l_List_findM_x3f___at_Lean_SearchPath_findWithExt___spec__1(x_1, x_2, x_3, x_4);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_5;
@@ -682,11 +564,10 @@ lean_object* x_5;
 x_5 = l_Lean_SearchPath_findWithExt(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l_IO_mkRef___at_Lean_initFn____x40_Lean_Util_Path___hyg_203____spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_IO_mkRef___at_Lean_initFn____x40_Lean_Util_Path___hyg_164____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -711,30 +592,12 @@ return x_7;
 }
 }
 }
-lean_object* l_Lean_initFn____x40_Lean_Util_Path___hyg_203_(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Util_Path___hyg_164_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = lean_box(0);
-x_3 = l_IO_mkRef___at_Lean_initFn____x40_Lean_Util_Path___hyg_203____spec__1(x_2, x_1);
-return x_3;
-}
-}
-lean_object* l_Lean_parseSearchPath(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; 
-x_3 = l_String_split___at_System_FilePath_splitSearchPath___spec__1(x_1);
-x_4 = l_List_append___rarg(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_parseSearchPath___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Lean_parseSearchPath(x_1, x_2);
-lean_dec(x_1);
+x_3 = l_IO_mkRef___at_Lean_initFn____x40_Lean_Util_Path___hyg_164____spec__1(x_2, x_1);
 return x_3;
 }
 }
@@ -769,7 +632,6 @@ if (x_3 == 0)
 lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_4 = lean_ctor_get(x_2, 0);
 x_5 = lean_ctor_get(x_2, 1);
-lean_inc(x_4);
 x_6 = l_System_FilePath_parent(x_4);
 if (lean_obj_tag(x_6) == 0)
 {
@@ -805,7 +667,6 @@ x_15 = lean_ctor_get(x_2, 1);
 lean_inc(x_15);
 lean_inc(x_14);
 lean_dec(x_2);
-lean_inc(x_14);
 x_16 = l_System_FilePath_parent(x_14);
 if (lean_obj_tag(x_16) == 0)
 {
@@ -858,7 +719,49 @@ return x_28;
 }
 }
 }
-static uint8_t _init_l_Lean_getBuiltinSearchPath___closed__1() {
+static lean_object* _init_l_Lean_getBuiltinSearchPath___lambda__1___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("lib");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_getBuiltinSearchPath___lambda__1___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("lean");
+return x_1;
+}
+}
+lean_object* l_Lean_getBuiltinSearchPath___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_4 = l_Lean_getBuiltinSearchPath___lambda__1___closed__1;
+x_5 = l_System_FilePath_join(x_1, x_4);
+x_6 = l_Lean_getBuiltinSearchPath___lambda__1___closed__2;
+x_7 = l_System_FilePath_join(x_5, x_6);
+x_8 = lean_box(0);
+x_9 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_9, 0, x_7);
+lean_ctor_set(x_9, 1, x_8);
+x_10 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_10, 0, x_9);
+lean_ctor_set(x_10, 1, x_3);
+return x_10;
+}
+}
+static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_getBuiltinSearchPath___lambda__1___boxed), 3, 0);
+return x_1;
+}
+}
+static uint8_t _init_l_Lean_getBuiltinSearchPath___closed__2() {
 _start:
 {
 lean_object* x_1; uint8_t x_2; 
@@ -867,60 +770,14 @@ x_2 = LEAN_IS_STAGE0;
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__2() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("lib");
-return x_1;
-}
-}
 static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("lean");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__4() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_2 = l_Lean_Syntax_formatStxAux___closed__3;
-x_3 = lean_string_append(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__5() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_getBuiltinSearchPath___closed__4;
-x_2 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_3 = lean_string_append(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__6() {
-_start:
-{
-lean_object* x_1; 
 x_1 = lean_mk_string("stage1");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__7() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_getBuiltinSearchPath___closed__5;
-x_2 = l_Lean_getBuiltinSearchPath___closed__6;
-x_3 = lean_string_append(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_getBuiltinSearchPath(lean_object* x_1) {
 _start:
 {
@@ -928,129 +785,65 @@ lean_object* x_2;
 x_2 = l_IO_appDir___at_Lean_getBuiltinSearchPath___spec__1(x_1);
 if (lean_obj_tag(x_2) == 0)
 {
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
+x_3 = lean_ctor_get(x_2, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_2, 1);
+lean_inc(x_4);
+lean_dec(x_2);
+x_5 = l_Lean_Syntax_formatStxAux___closed__3;
+x_6 = l_System_FilePath_join(x_3, x_5);
+x_7 = l_Lean_getBuiltinSearchPath___closed__1;
+x_8 = l_Lean_getBuiltinSearchPath___closed__2;
+if (x_8 == 0)
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_6 = lean_string_append(x_4, x_5);
-x_7 = l_Lean_Syntax_formatStxAux___closed__3;
-x_8 = lean_string_append(x_6, x_7);
+lean_object* x_9; lean_object* x_10; 
 x_9 = lean_box(0);
-x_10 = l_Lean_getBuiltinSearchPath___closed__1;
-if (x_10 == 0)
+x_10 = lean_apply_3(x_7, x_6, x_9, x_4);
+return x_10;
+}
+else
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_11 = l_Lean_instInhabitedParserDescr___closed__1;
-x_12 = lean_string_append(x_8, x_11);
-x_13 = lean_string_append(x_12, x_5);
-x_14 = l_Lean_getBuiltinSearchPath___closed__2;
-x_15 = lean_string_append(x_13, x_14);
-x_16 = lean_string_append(x_15, x_5);
-x_17 = l_Lean_getBuiltinSearchPath___closed__3;
-x_18 = lean_string_append(x_16, x_17);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_11 = l_System_FilePath_join(x_6, x_5);
+x_12 = l_Lean_getBuiltinSearchPath___closed__3;
+x_13 = l_System_FilePath_join(x_11, x_12);
+x_14 = lean_box(0);
+x_15 = lean_apply_3(x_7, x_13, x_14, x_4);
+return x_15;
+}
+}
+else
+{
+uint8_t x_16; 
+x_16 = !lean_is_exclusive(x_2);
+if (x_16 == 0)
+{
+return x_2;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_17 = lean_ctor_get(x_2, 0);
+x_18 = lean_ctor_get(x_2, 1);
+lean_inc(x_18);
+lean_inc(x_17);
+lean_dec(x_2);
 x_19 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_19, 0, x_18);
-lean_ctor_set(x_19, 1, x_9);
-lean_ctor_set(x_2, 0, x_19);
-return x_2;
+lean_ctor_set(x_19, 0, x_17);
+lean_ctor_set(x_19, 1, x_18);
+return x_19;
 }
-else
+}
+}
+}
+lean_object* l_Lean_getBuiltinSearchPath___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_20 = l_Lean_getBuiltinSearchPath___closed__7;
-x_21 = lean_string_append(x_8, x_20);
-x_22 = lean_string_append(x_21, x_5);
-x_23 = l_Lean_getBuiltinSearchPath___closed__2;
-x_24 = lean_string_append(x_22, x_23);
-x_25 = lean_string_append(x_24, x_5);
-x_26 = l_Lean_getBuiltinSearchPath___closed__3;
-x_27 = lean_string_append(x_25, x_26);
-x_28 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_28, 0, x_27);
-lean_ctor_set(x_28, 1, x_9);
-lean_ctor_set(x_2, 0, x_28);
-return x_2;
-}
-}
-else
-{
-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; uint8_t x_36; 
-x_29 = lean_ctor_get(x_2, 0);
-x_30 = lean_ctor_get(x_2, 1);
-lean_inc(x_30);
-lean_inc(x_29);
+lean_object* x_4; 
+x_4 = l_Lean_getBuiltinSearchPath___lambda__1(x_1, x_2, x_3);
 lean_dec(x_2);
-x_31 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_32 = lean_string_append(x_29, x_31);
-x_33 = l_Lean_Syntax_formatStxAux___closed__3;
-x_34 = lean_string_append(x_32, x_33);
-x_35 = lean_box(0);
-x_36 = l_Lean_getBuiltinSearchPath___closed__1;
-if (x_36 == 0)
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_37 = l_Lean_instInhabitedParserDescr___closed__1;
-x_38 = lean_string_append(x_34, x_37);
-x_39 = lean_string_append(x_38, x_31);
-x_40 = l_Lean_getBuiltinSearchPath___closed__2;
-x_41 = lean_string_append(x_39, x_40);
-x_42 = lean_string_append(x_41, x_31);
-x_43 = l_Lean_getBuiltinSearchPath___closed__3;
-x_44 = lean_string_append(x_42, x_43);
-x_45 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_45, 0, x_44);
-lean_ctor_set(x_45, 1, x_35);
-x_46 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_46, 0, x_45);
-lean_ctor_set(x_46, 1, x_30);
-return x_46;
-}
-else
-{
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_47 = l_Lean_getBuiltinSearchPath___closed__7;
-x_48 = lean_string_append(x_34, x_47);
-x_49 = lean_string_append(x_48, x_31);
-x_50 = l_Lean_getBuiltinSearchPath___closed__2;
-x_51 = lean_string_append(x_49, x_50);
-x_52 = lean_string_append(x_51, x_31);
-x_53 = l_Lean_getBuiltinSearchPath___closed__3;
-x_54 = lean_string_append(x_52, x_53);
-x_55 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_35);
-x_56 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_56, 0, x_55);
-lean_ctor_set(x_56, 1, x_30);
-return x_56;
-}
-}
-}
-else
-{
-uint8_t x_57; 
-x_57 = !lean_is_exclusive(x_2);
-if (x_57 == 0)
-{
-return x_2;
-}
-else
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_2, 0);
-x_59 = lean_ctor_get(x_2, 1);
-lean_inc(x_59);
-lean_inc(x_58);
-lean_dec(x_2);
-x_60 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_60, 0, x_58);
-lean_ctor_set(x_60, 1, x_59);
-return x_60;
-}
-}
+return x_4;
 }
 }
 lean_object* l_Lean_addSearchPathFromEnv_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -1141,56 +934,58 @@ uint8_t x_10;
 x_10 = !lean_is_exclusive(x_4);
 if (x_10 == 0)
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
 x_11 = lean_ctor_get(x_4, 0);
 lean_dec(x_11);
 x_12 = lean_ctor_get(x_5, 0);
 lean_inc(x_12);
 lean_dec(x_5);
-x_13 = l_Lean_parseSearchPath(x_12, x_1);
+x_13 = l_System_SearchPath_parse(x_12);
 lean_dec(x_12);
-lean_ctor_set(x_4, 0, x_13);
+x_14 = l_List_append___rarg(x_13, x_1);
+lean_ctor_set(x_4, 0, x_14);
 return x_4;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_14 = lean_ctor_get(x_4, 1);
-lean_inc(x_14);
-lean_dec(x_4);
-x_15 = lean_ctor_get(x_5, 0);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_15 = lean_ctor_get(x_4, 1);
 lean_inc(x_15);
+lean_dec(x_4);
+x_16 = lean_ctor_get(x_5, 0);
+lean_inc(x_16);
 lean_dec(x_5);
-x_16 = l_Lean_parseSearchPath(x_15, x_1);
-lean_dec(x_15);
-x_17 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_17, 0, x_16);
-lean_ctor_set(x_17, 1, x_14);
-return x_17;
+x_17 = l_System_SearchPath_parse(x_16);
+lean_dec(x_16);
+x_18 = l_List_append___rarg(x_17, x_1);
+x_19 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_19, 0, x_18);
+lean_ctor_set(x_19, 1, x_15);
+return x_19;
 }
 }
 }
 else
 {
-uint8_t x_18; 
+uint8_t x_20; 
 lean_dec(x_1);
-x_18 = !lean_is_exclusive(x_4);
-if (x_18 == 0)
+x_20 = !lean_is_exclusive(x_4);
+if (x_20 == 0)
 {
 return x_4;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_ctor_get(x_4, 0);
-x_20 = lean_ctor_get(x_4, 1);
-lean_inc(x_20);
-lean_inc(x_19);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_4, 0);
+x_22 = lean_ctor_get(x_4, 1);
+lean_inc(x_22);
+lean_inc(x_21);
 lean_dec(x_4);
-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;
+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;
 }
 }
 }
@@ -1328,32 +1123,31 @@ return x_22;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
 x_23 = lean_ctor_get(x_1, 0);
 lean_inc(x_23);
 lean_dec(x_1);
-x_24 = lean_box(0);
-x_25 = l_Lean_parseSearchPath(x_23, x_24);
+x_24 = l_System_SearchPath_parse(x_23);
 lean_dec(x_23);
-x_26 = l_Lean_searchPathRef;
-x_27 = lean_st_ref_set(x_26, x_25, x_2);
-x_28 = !lean_is_exclusive(x_27);
-if (x_28 == 0)
+x_25 = l_Lean_searchPathRef;
+x_26 = lean_st_ref_set(x_25, x_24, x_2);
+x_27 = !lean_is_exclusive(x_26);
+if (x_27 == 0)
 {
-return x_27;
+return x_26;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = lean_ctor_get(x_27, 0);
-x_30 = lean_ctor_get(x_27, 1);
-lean_inc(x_30);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = lean_ctor_get(x_26, 0);
+x_29 = lean_ctor_get(x_26, 1);
 lean_inc(x_29);
-lean_dec(x_27);
-x_31 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_31, 0, x_29);
-lean_ctor_set(x_31, 1, x_30);
-return x_31;
+lean_inc(x_28);
+lean_dec(x_26);
+x_30 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_30, 0, x_28);
+lean_ctor_set(x_30, 1, x_29);
+return x_30;
 }
 }
 }
@@ -1388,6 +1182,36 @@ x_2 = lean_alloc_closure((void*)(l_Lean_findOLean_maybeThisOne_match__1___rarg),
 return x_2;
 }
 }
+lean_object* l_Lean_findOLean_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+}
+}
+lean_object* l_Lean_findOLean_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_findOLean_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_findOLean_maybeThisOne___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -1410,6 +1234,7 @@ x_8 = lean_ctor_get(x_5, 0);
 lean_inc(x_8);
 lean_dec(x_5);
 x_9 = l_Lean_findOLean_maybeThisOne(x_2, x_8, x_4);
+lean_dec(x_8);
 return x_9;
 }
 }
@@ -1433,100 +1258,60 @@ return x_1;
 lean_object* l_Lean_findOLean_maybeThisOne(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_4 = l_Lean_instInhabitedParserDescr___closed__1;
-x_5 = lean_string_append(x_4, x_2);
-x_6 = lean_string_append(x_5, x_4);
-x_7 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_8 = lean_string_append(x_6, x_7);
-x_9 = lean_string_append(x_8, x_4);
-x_10 = 1;
+lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
 lean_inc(x_1);
-x_11 = l_Lean_Name_toString(x_1, x_10);
-x_12 = lean_string_append(x_9, x_11);
-lean_dec(x_11);
-x_13 = lean_string_append(x_12, x_4);
-x_14 = lean_io_file_exists(x_13, x_3);
-lean_dec(x_13);
-if (lean_obj_tag(x_14) == 0)
+x_4 = l_System_FilePath_join(x_1, x_2);
+x_5 = l_System_FilePath_isDir(x_4, x_3);
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+x_7 = lean_unbox(x_6);
+lean_dec(x_6);
+if (x_7 == 0)
 {
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_unbox(x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_17 = lean_ctor_get(x_14, 1);
-lean_inc(x_17);
-lean_dec(x_14);
-x_18 = lean_box(0);
-x_19 = l_Lean_findOLean_maybeThisOne___lambda__1(x_2, x_1, x_18, x_17);
-return x_19;
+lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_8 = lean_ctor_get(x_5, 1);
+lean_inc(x_8);
+lean_dec(x_5);
+x_9 = lean_box(0);
+x_10 = l_Lean_findOLean_maybeThisOne___lambda__1(x_2, x_1, x_9, x_8);
+return x_10;
 }
 else
 {
-uint8_t x_20; 
+uint8_t x_11; 
 lean_dec(x_1);
-x_20 = !lean_is_exclusive(x_14);
-if (x_20 == 0)
+x_11 = !lean_is_exclusive(x_5);
+if (x_11 == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_21 = lean_ctor_get(x_14, 0);
-lean_dec(x_21);
-x_22 = l_Lean_findOLean_maybeThisOne___closed__1;
-x_23 = lean_string_append(x_22, x_2);
-lean_dec(x_2);
-x_24 = l_Lean_findOLean_maybeThisOne___closed__2;
-x_25 = lean_string_append(x_23, x_24);
-x_26 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_14, 0, x_26);
-return x_14;
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_12 = lean_ctor_get(x_5, 0);
+lean_dec(x_12);
+x_13 = l_Lean_findOLean_maybeThisOne___closed__1;
+x_14 = lean_string_append(x_13, x_2);
+x_15 = l_Lean_findOLean_maybeThisOne___closed__2;
+x_16 = lean_string_append(x_14, x_15);
+x_17 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_17, 0, x_16);
+lean_ctor_set(x_5, 0, x_17);
+return x_5;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_27 = lean_ctor_get(x_14, 1);
-lean_inc(x_27);
-lean_dec(x_14);
-x_28 = l_Lean_findOLean_maybeThisOne___closed__1;
-x_29 = lean_string_append(x_28, x_2);
-lean_dec(x_2);
-x_30 = l_Lean_findOLean_maybeThisOne___closed__2;
-x_31 = lean_string_append(x_29, x_30);
-x_32 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_32, 0, x_31);
-x_33 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_27);
-return x_33;
-}
-}
-}
-else
-{
-uint8_t x_34; 
-lean_dec(x_2);
-lean_dec(x_1);
-x_34 = !lean_is_exclusive(x_14);
-if (x_34 == 0)
-{
-return x_14;
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_14, 0);
-x_36 = lean_ctor_get(x_14, 1);
-lean_inc(x_36);
-lean_inc(x_35);
-lean_dec(x_14);
-x_37 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_36);
-return x_37;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_18 = lean_ctor_get(x_5, 1);
+lean_inc(x_18);
+lean_dec(x_5);
+x_19 = l_Lean_findOLean_maybeThisOne___closed__1;
+x_20 = lean_string_append(x_19, x_2);
+x_21 = l_Lean_findOLean_maybeThisOne___closed__2;
+x_22 = lean_string_append(x_20, x_21);
+x_23 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_23, 0, x_22);
+x_24 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_24, 0, x_23);
+lean_ctor_set(x_24, 1, x_18);
+return x_24;
 }
 }
 }
@@ -1537,9 +1322,19 @@ _start:
 lean_object* x_5; 
 x_5 = l_Lean_findOLean_maybeThisOne___lambda__1(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
+lean_dec(x_1);
 return x_5;
 }
 }
+lean_object* l_Lean_findOLean_maybeThisOne___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_findOLean_maybeThisOne(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
 lean_object* l_IO_currentDir___at_Lean_findOLean___spec__1(lean_object* x_1) {
 _start:
 {
@@ -1564,7 +1359,7 @@ static lean_object* _init_l_Lean_findOLean___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string(".olean");
+x_1 = lean_mk_string("olean");
 return x_1;
 }
 }
@@ -1587,7 +1382,7 @@ return x_1;
 lean_object* l_Lean_findOLean(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
 x_3 = l_Lean_searchPathRef;
 x_4 = lean_st_ref_get(x_3, x_2);
 x_5 = lean_ctor_get(x_4, 0);
@@ -1597,10 +1392,6 @@ lean_inc(x_6);
 lean_dec(x_4);
 x_7 = l_Lean_findOLean___closed__1;
 x_8 = l_Lean_SearchPath_findWithExt(x_5, x_7, x_1, x_6);
-lean_dec(x_5);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; 
 x_9 = lean_ctor_get(x_8, 0);
 lean_inc(x_9);
 if (lean_obj_tag(x_9) == 0)
@@ -1611,26 +1402,22 @@ lean_inc(x_10);
 lean_dec(x_8);
 x_11 = l_Lean_Name_getRoot(x_1);
 x_12 = 1;
-lean_inc(x_11);
 x_13 = l_Lean_Name_toString(x_11, x_12);
 x_14 = l_Lean_findOLean___closed__2;
 x_15 = lean_string_append(x_14, x_13);
-lean_dec(x_13);
 x_16 = l_Char_quote___closed__1;
 x_17 = lean_string_append(x_15, x_16);
 x_18 = lean_io_current_dir(x_10);
 if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
 x_19 = lean_ctor_get(x_18, 0);
 lean_inc(x_19);
 x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
 lean_dec(x_18);
-x_21 = l_Lean_findOLean_maybeThisOne(x_11, x_19, x_20);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_21 = l_Lean_findOLean_maybeThisOne(x_13, x_19, x_20);
+lean_dec(x_19);
 x_22 = lean_ctor_get(x_21, 0);
 lean_inc(x_22);
 x_23 = lean_ctor_get(x_21, 1);
@@ -1661,19 +1448,20 @@ else
 {
 uint8_t x_31; 
 lean_dec(x_17);
-x_31 = !lean_is_exclusive(x_21);
+lean_dec(x_13);
+x_31 = !lean_is_exclusive(x_18);
 if (x_31 == 0)
 {
-return x_21;
+return x_18;
 }
 else
 {
 lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_32 = lean_ctor_get(x_21, 0);
-x_33 = lean_ctor_get(x_21, 1);
+x_32 = lean_ctor_get(x_18, 0);
+x_33 = lean_ctor_get(x_18, 1);
 lean_inc(x_33);
 lean_inc(x_32);
-lean_dec(x_21);
+lean_dec(x_18);
 x_34 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_34, 0, x_32);
 lean_ctor_set(x_34, 1, x_33);
@@ -1684,79 +1472,31 @@ return x_34;
 else
 {
 uint8_t x_35; 
-lean_dec(x_17);
-lean_dec(x_11);
-x_35 = !lean_is_exclusive(x_18);
+x_35 = !lean_is_exclusive(x_8);
 if (x_35 == 0)
 {
-return x_18;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_18, 0);
-x_37 = lean_ctor_get(x_18, 1);
+lean_object* x_36; lean_object* x_37; 
+x_36 = lean_ctor_get(x_8, 0);
+lean_dec(x_36);
+x_37 = lean_ctor_get(x_9, 0);
 lean_inc(x_37);
-lean_inc(x_36);
-lean_dec(x_18);
-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;
-}
-}
-}
-else
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_8);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; 
-x_40 = lean_ctor_get(x_8, 0);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_9, 0);
-lean_inc(x_41);
 lean_dec(x_9);
-lean_ctor_set(x_8, 0, x_41);
+lean_ctor_set(x_8, 0, x_37);
 return x_8;
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_42 = lean_ctor_get(x_8, 1);
-lean_inc(x_42);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_38 = lean_ctor_get(x_8, 1);
+lean_inc(x_38);
 lean_dec(x_8);
-x_43 = lean_ctor_get(x_9, 0);
-lean_inc(x_43);
+x_39 = lean_ctor_get(x_9, 0);
+lean_inc(x_39);
 lean_dec(x_9);
-x_44 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_44, 0, x_43);
-lean_ctor_set(x_44, 1, x_42);
-return x_44;
-}
-}
-}
-else
-{
-uint8_t x_45; 
-x_45 = !lean_is_exclusive(x_8);
-if (x_45 == 0)
-{
-return x_8;
-}
-else
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-x_46 = lean_ctor_get(x_8, 0);
-x_47 = lean_ctor_get(x_8, 1);
-lean_inc(x_47);
-lean_inc(x_46);
-lean_dec(x_8);
-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;
+x_40 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_40, 0, x_39);
+lean_ctor_set(x_40, 1, x_38);
+return x_40;
 }
 }
 }
@@ -1810,36 +1550,6 @@ x_2 = lean_alloc_closure((void*)(l_Lean_moduleNameOfFileName_match__1___rarg), 3
 return x_2;
 }
 }
-lean_object* l_Lean_moduleNameOfFileName_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-if (lean_obj_tag(x_1) == 0)
-{
-lean_object* x_4; 
-lean_dec(x_2);
-x_4 = lean_apply_1(x_3, x_1);
-return x_4;
-}
-else
-{
-lean_object* x_5; lean_object* x_6; 
-lean_dec(x_3);
-x_5 = lean_ctor_get(x_1, 0);
-lean_inc(x_5);
-lean_dec(x_1);
-x_6 = lean_apply_1(x_2, x_5);
-return x_6;
-}
-}
-}
-lean_object* l_Lean_moduleNameOfFileName_match__2(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_moduleNameOfFileName_match__2___rarg), 3, 0);
-return x_2;
-}
-}
 lean_object* l_List_foldl___at_Lean_moduleNameOfFileName___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1862,116 +1572,21 @@ goto _start;
 }
 }
 }
-static lean_object* _init_l_Lean_moduleNameOfFileName___lambda__1___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("failed to convert file name '");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_moduleNameOfFileName___lambda__1___closed__2() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("' to module name, extension is missing");
-return x_1;
-}
-}
 lean_object* l_Lean_moduleNameOfFileName___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; uint32_t x_8; uint32_t x_9; uint8_t x_10; uint32_t x_11; 
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 x_5 = lean_string_length(x_1);
-lean_inc(x_2);
 x_6 = l_String_drop(x_2, x_5);
-x_7 = lean_unsigned_to_nat(0u);
-x_8 = lean_string_utf8_get(x_6, x_7);
-x_9 = l_System_FilePath_pathSeparator;
-x_10 = x_8 == x_9;
-x_11 = 46;
-if (x_10 == 0)
-{
-lean_object* x_12; 
-x_12 = l_String_revPosOf(x_6, x_11);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_dec(x_6);
-x_13 = l_Lean_moduleNameOfFileName___lambda__1___closed__1;
-x_14 = lean_string_append(x_13, x_2);
-lean_dec(x_2);
-x_15 = l_Lean_moduleNameOfFileName___lambda__1___closed__2;
-x_16 = lean_string_append(x_14, x_15);
-x_17 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_17, 0, x_16);
-x_18 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_4);
-return x_18;
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-lean_dec(x_2);
-x_19 = lean_ctor_get(x_12, 0);
-lean_inc(x_19);
-lean_dec(x_12);
-x_20 = lean_string_utf8_extract(x_6, x_7, x_19);
-lean_dec(x_19);
-lean_dec(x_6);
-x_21 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_22 = l_String_splitOn(x_20, x_21);
-x_23 = lean_box(0);
-x_24 = l_List_foldl___at_Lean_moduleNameOfFileName___spec__1(x_23, x_22);
-x_25 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_25, 0, x_24);
-lean_ctor_set(x_25, 1, x_4);
-return x_25;
-}
-}
-else
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_26 = lean_unsigned_to_nat(1u);
-x_27 = l_String_drop(x_6, x_26);
-x_28 = l_String_revPosOf(x_27, x_11);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_27);
-x_29 = l_Lean_moduleNameOfFileName___lambda__1___closed__1;
-x_30 = lean_string_append(x_29, x_2);
-lean_dec(x_2);
-x_31 = l_Lean_moduleNameOfFileName___lambda__1___closed__2;
-x_32 = lean_string_append(x_30, x_31);
-x_33 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_33, 0, x_32);
-x_34 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_34, 0, x_33);
-lean_ctor_set(x_34, 1, x_4);
-return x_34;
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_2);
-x_35 = lean_ctor_get(x_28, 0);
-lean_inc(x_35);
-lean_dec(x_28);
-x_36 = lean_string_utf8_extract(x_27, x_7, x_35);
-lean_dec(x_35);
-lean_dec(x_27);
-x_37 = l___private_Lean_Util_Path_0__Lean_pathSep;
-x_38 = l_String_splitOn(x_36, x_37);
-x_39 = lean_box(0);
-x_40 = l_List_foldl___at_Lean_moduleNameOfFileName___spec__1(x_39, x_38);
-x_41 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_41, 0, x_40);
-lean_ctor_set(x_41, 1, x_4);
-return x_41;
-}
-}
+x_7 = l_Lean_instInhabitedParserDescr___closed__1;
+x_8 = l_System_FilePath_withExtension(x_6, x_7);
+x_9 = l_System_FilePath_components(x_8);
+x_10 = lean_box(0);
+x_11 = l_List_foldl___at_Lean_moduleNameOfFileName___spec__1(x_10, x_9);
+x_12 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_12, 0, x_11);
+lean_ctor_set(x_12, 1, x_4);
+return x_12;
 }
 }
 static lean_object* _init_l_Lean_moduleNameOfFileName___lambda__2___closed__1() {
@@ -1990,108 +1605,97 @@ x_1 = lean_mk_string("' must be contained in root directory (");
 return x_1;
 }
 }
-lean_object* l_Lean_moduleNameOfFileName___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_moduleNameOfFileName___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; lean_object* x_6; uint8_t x_7; 
+x_5 = l_System_FilePath_isCaseInsensitive;
+lean_inc(x_1);
+x_6 = l_System_FilePath_normalize(x_1, x_5);
+x_7 = l_String_isPrefixOf(x_2, x_6);
+lean_dec(x_6);
+if (x_7 == 0)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_8 = l_Lean_moduleNameOfFileName___lambda__2___closed__1;
+x_9 = lean_string_append(x_8, x_1);
+lean_dec(x_1);
+x_10 = l_Lean_moduleNameOfFileName___lambda__2___closed__2;
+x_11 = lean_string_append(x_9, x_10);
+x_12 = lean_string_append(x_11, x_2);
+x_13 = l_prec_x28___x29___closed__7;
+x_14 = lean_string_append(x_12, x_13);
+x_15 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_15, 0, x_14);
+x_16 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_16, 0, x_15);
+lean_ctor_set(x_16, 1, x_4);
+return x_16;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; 
+x_17 = lean_box(0);
+x_18 = l_Lean_moduleNameOfFileName___lambda__1(x_2, x_1, x_17, x_4);
+return x_18;
+}
+}
+}
+lean_object* l_Lean_moduleNameOfFileName___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
 x_4 = l_Lean_realPathNormalized(x_2, x_3);
 if (lean_obj_tag(x_4) == 0)
 {
-uint8_t x_5; 
-x_5 = !lean_is_exclusive(x_4);
-if (x_5 == 0)
-{
-lean_object* x_6; lean_object* x_7; uint8_t x_8; 
-x_6 = lean_ctor_get(x_4, 0);
-x_7 = lean_ctor_get(x_4, 1);
-x_8 = l_String_isPrefixOf(x_6, x_1);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_4, 1);
+lean_inc(x_6);
+lean_dec(x_4);
+x_7 = l_System_FilePath_join___closed__1;
+lean_inc(x_5);
+x_8 = l_String_endsWith(x_5, x_7);
 if (x_8 == 0)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_9 = l_Lean_moduleNameOfFileName___lambda__2___closed__1;
-x_10 = lean_string_append(x_9, x_1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_9 = lean_string_append(x_5, x_7);
+x_10 = lean_box(0);
+x_11 = l_Lean_moduleNameOfFileName___lambda__2(x_1, x_9, x_10, x_6);
+lean_dec(x_9);
+return x_11;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; 
+x_12 = lean_box(0);
+x_13 = l_Lean_moduleNameOfFileName___lambda__2(x_1, x_5, x_12, x_6);
+lean_dec(x_5);
+return x_13;
+}
+}
+else
+{
+uint8_t x_14; 
 lean_dec(x_1);
-x_11 = l_Lean_moduleNameOfFileName___lambda__2___closed__2;
-x_12 = lean_string_append(x_10, x_11);
-x_13 = lean_string_append(x_12, x_6);
-lean_dec(x_6);
-x_14 = l_prec_x28___x29___closed__7;
-x_15 = lean_string_append(x_13, x_14);
-x_16 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_16, 0, x_15);
-lean_ctor_set_tag(x_4, 1);
-lean_ctor_set(x_4, 0, x_16);
-return x_4;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-lean_free_object(x_4);
-x_17 = lean_box(0);
-x_18 = l_Lean_moduleNameOfFileName___lambda__1(x_6, x_1, x_17, x_7);
-lean_dec(x_6);
-return x_18;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; uint8_t x_21; 
-x_19 = lean_ctor_get(x_4, 0);
-x_20 = lean_ctor_get(x_4, 1);
-lean_inc(x_20);
-lean_inc(x_19);
-lean_dec(x_4);
-x_21 = l_String_isPrefixOf(x_19, x_1);
-if (x_21 == 0)
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_22 = l_Lean_moduleNameOfFileName___lambda__2___closed__1;
-x_23 = lean_string_append(x_22, x_1);
-lean_dec(x_1);
-x_24 = l_Lean_moduleNameOfFileName___lambda__2___closed__2;
-x_25 = lean_string_append(x_23, x_24);
-x_26 = lean_string_append(x_25, x_19);
-lean_dec(x_19);
-x_27 = l_prec_x28___x29___closed__7;
-x_28 = lean_string_append(x_26, x_27);
-x_29 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_29, 0, x_28);
-x_30 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_30, 0, x_29);
-lean_ctor_set(x_30, 1, x_20);
-return x_30;
-}
-else
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_box(0);
-x_32 = l_Lean_moduleNameOfFileName___lambda__1(x_19, x_1, x_31, x_20);
-lean_dec(x_19);
-return x_32;
-}
-}
-}
-else
-{
-uint8_t x_33; 
-lean_dec(x_1);
-x_33 = !lean_is_exclusive(x_4);
-if (x_33 == 0)
+x_14 = !lean_is_exclusive(x_4);
+if (x_14 == 0)
 {
 return x_4;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_34 = lean_ctor_get(x_4, 0);
-x_35 = lean_ctor_get(x_4, 1);
-lean_inc(x_35);
-lean_inc(x_34);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_15 = lean_ctor_get(x_4, 0);
+x_16 = lean_ctor_get(x_4, 1);
+lean_inc(x_16);
+lean_inc(x_15);
 lean_dec(x_4);
-x_36 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_36, 0, x_34);
-lean_ctor_set(x_36, 1, x_35);
-return x_36;
+x_17 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_17, 0, x_15);
+lean_ctor_set(x_17, 1, x_16);
+return x_17;
 }
 }
 }
@@ -2100,7 +1704,7 @@ lean_object* lean_module_name_of_file(lean_object* x_1, lean_object* x_2, lean_o
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_realPathNormalized(x_1, x_3);
+x_4 = lean_io_realpath(x_1, x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 if (lean_obj_tag(x_2) == 0)
@@ -2120,7 +1724,7 @@ lean_inc(x_8);
 x_9 = lean_ctor_get(x_7, 1);
 lean_inc(x_9);
 lean_dec(x_7);
-x_10 = l_Lean_moduleNameOfFileName___lambda__2(x_5, x_8, x_9);
+x_10 = l_Lean_moduleNameOfFileName___lambda__3(x_5, x_8, x_9);
 return x_10;
 }
 else
@@ -2158,7 +1762,7 @@ lean_dec(x_4);
 x_17 = lean_ctor_get(x_2, 0);
 lean_inc(x_17);
 lean_dec(x_2);
-x_18 = l_Lean_moduleNameOfFileName___lambda__2(x_15, x_17, x_16);
+x_18 = l_Lean_moduleNameOfFileName___lambda__3(x_15, x_17, x_16);
 return x_18;
 }
 }
@@ -2197,6 +1801,16 @@ lean_dec(x_1);
 return x_5;
 }
 }
+lean_object* l_Lean_moduleNameOfFileName___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Lean_moduleNameOfFileName___lambda__2(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_5;
+}
+}
 lean_object* initialize_Init(lean_object*);
 lean_object* initialize_Lean_Data_Name(lean_object*);
 static bool _G_initialized = false;
@@ -2210,34 +1824,28 @@ lean_dec_ref(res);
 res = initialize_Lean_Data_Name(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l___private_Lean_Util_Path_0__Lean_pathSep = _init_l___private_Lean_Util_Path_0__Lean_pathSep();
-lean_mark_persistent(l___private_Lean_Util_Path_0__Lean_pathSep);
-l_Lean_modPathToFilePath___closed__1 = _init_l_Lean_modPathToFilePath___closed__1();
-lean_mark_persistent(l_Lean_modPathToFilePath___closed__1);
-l_Lean_modPathToFilePath___closed__2 = _init_l_Lean_modPathToFilePath___closed__2();
-lean_mark_persistent(l_Lean_modPathToFilePath___closed__2);
-l_Lean_modPathToFilePath___closed__3 = _init_l_Lean_modPathToFilePath___closed__3();
-lean_mark_persistent(l_Lean_modPathToFilePath___closed__3);
-l_Lean_modPathToFilePath___closed__4 = _init_l_Lean_modPathToFilePath___closed__4();
-lean_mark_persistent(l_Lean_modPathToFilePath___closed__4);
-res = l_Lean_initFn____x40_Lean_Util_Path___hyg_203_(lean_io_mk_world());
+l_Lean_modToFilePath_go___closed__1 = _init_l_Lean_modToFilePath_go___closed__1();
+lean_mark_persistent(l_Lean_modToFilePath_go___closed__1);
+l_Lean_modToFilePath_go___closed__2 = _init_l_Lean_modToFilePath_go___closed__2();
+lean_mark_persistent(l_Lean_modToFilePath_go___closed__2);
+l_Lean_modToFilePath_go___closed__3 = _init_l_Lean_modToFilePath_go___closed__3();
+lean_mark_persistent(l_Lean_modToFilePath_go___closed__3);
+l_Lean_modToFilePath_go___closed__4 = _init_l_Lean_modToFilePath_go___closed__4();
+lean_mark_persistent(l_Lean_modToFilePath_go___closed__4);
+res = l_Lean_initFn____x40_Lean_Util_Path___hyg_164_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_searchPathRef = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_searchPathRef);
 lean_dec_ref(res);
+l_Lean_getBuiltinSearchPath___lambda__1___closed__1 = _init_l_Lean_getBuiltinSearchPath___lambda__1___closed__1();
+lean_mark_persistent(l_Lean_getBuiltinSearchPath___lambda__1___closed__1);
+l_Lean_getBuiltinSearchPath___lambda__1___closed__2 = _init_l_Lean_getBuiltinSearchPath___lambda__1___closed__2();
+lean_mark_persistent(l_Lean_getBuiltinSearchPath___lambda__1___closed__2);
 l_Lean_getBuiltinSearchPath___closed__1 = _init_l_Lean_getBuiltinSearchPath___closed__1();
+lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__1);
 l_Lean_getBuiltinSearchPath___closed__2 = _init_l_Lean_getBuiltinSearchPath___closed__2();
-lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__2);
 l_Lean_getBuiltinSearchPath___closed__3 = _init_l_Lean_getBuiltinSearchPath___closed__3();
 lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__3);
-l_Lean_getBuiltinSearchPath___closed__4 = _init_l_Lean_getBuiltinSearchPath___closed__4();
-lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__4);
-l_Lean_getBuiltinSearchPath___closed__5 = _init_l_Lean_getBuiltinSearchPath___closed__5();
-lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__5);
-l_Lean_getBuiltinSearchPath___closed__6 = _init_l_Lean_getBuiltinSearchPath___closed__6();
-lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__6);
-l_Lean_getBuiltinSearchPath___closed__7 = _init_l_Lean_getBuiltinSearchPath___closed__7();
-lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__7);
 l_Lean_addSearchPathFromEnv___closed__1 = _init_l_Lean_addSearchPathFromEnv___closed__1();
 lean_mark_persistent(l_Lean_addSearchPathFromEnv___closed__1);
 l_Lean_findOLean_maybeThisOne___closed__1 = _init_l_Lean_findOLean_maybeThisOne___closed__1();
@@ -2250,10 +1858,6 @@ l_Lean_findOLean___closed__2 = _init_l_Lean_findOLean___closed__2();
 lean_mark_persistent(l_Lean_findOLean___closed__2);
 l_Lean_findOLean___closed__3 = _init_l_Lean_findOLean___closed__3();
 lean_mark_persistent(l_Lean_findOLean___closed__3);
-l_Lean_moduleNameOfFileName___lambda__1___closed__1 = _init_l_Lean_moduleNameOfFileName___lambda__1___closed__1();
-lean_mark_persistent(l_Lean_moduleNameOfFileName___lambda__1___closed__1);
-l_Lean_moduleNameOfFileName___lambda__1___closed__2 = _init_l_Lean_moduleNameOfFileName___lambda__1___closed__2();
-lean_mark_persistent(l_Lean_moduleNameOfFileName___lambda__1___closed__2);
 l_Lean_moduleNameOfFileName___lambda__2___closed__1 = _init_l_Lean_moduleNameOfFileName___lambda__2___closed__1();
 lean_mark_persistent(l_Lean_moduleNameOfFileName___lambda__2___closed__1);
 l_Lean_moduleNameOfFileName___lambda__2___closed__2 = _init_l_Lean_moduleNameOfFileName___lambda__2___closed__2();
diff --git a/stage0/stdlib/Lean/Util/Recognizers.c b/stage0/stdlib/Lean/Util/Recognizers.c
index f576ece7cc..c67959004a 100644
--- a/stage0/stdlib/Lean/Util/Recognizers.c
+++ b/stage0/stdlib/Lean/Util/Recognizers.c
@@ -58,13 +58,13 @@ lean_object* l_Lean_Expr_app3_x3f___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_app2_x3f(lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isAppOfArity(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f___closed__2;
-extern lean_object* l_myMacro____x40_Init_Core___hyg_1874____closed__4;
 extern lean_object* l_Lean_Literal_type___closed__2;
 lean_object* l_Lean_Expr_const_x3f_match__1(lean_object*);
 lean_object* l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_ne_x3f(lean_object*);
 extern lean_object* l_myMacro____x40_Init_Core___hyg_184____closed__4;
 extern lean_object* l_myMacro____x40_Init_Notation___hyg_71____closed__2;
+extern lean_object* l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 lean_object* l_Lean_Expr_app3_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_heq_x3f___boxed(lean_object*);
 lean_object* l_Lean_Expr_const_x3f(lean_object*);
@@ -383,7 +383,7 @@ lean_object* l_Lean_Expr_ne_x3f(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; uint8_t x_4; 
-x_2 = l_myMacro____x40_Init_Core___hyg_1874____closed__4;
+x_2 = l_myMacro____x40_Init_Core___hyg_1890____closed__4;
 x_3 = lean_unsigned_to_nat(3u);
 x_4 = l_Lean_Expr_isAppOfArity(x_1, x_2, x_3);
 if (x_4 == 0)