chore: update stage0

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
 

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

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
 

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

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

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
 

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
 

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

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

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
+end Lean.Lsp.Ipc

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

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

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

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

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

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

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

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

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

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 }

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

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
 

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

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

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

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

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

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
 

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

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

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

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

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

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

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

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

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

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

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

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

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;

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;

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

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

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

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

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

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

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

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

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; 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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; 

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

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

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

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

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

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

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

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;

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

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